home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 4 / QRZ Ham Radio Callsign Database - Volume 4.iso / files / dsp / 56ktools / dspkgctr.z / dspkgctr / gcc / loop.c < prev    next >
C/C++ Source or Header  |  1992-06-08  |  201KB  |  6,909 lines
  1. /* Move constant computations out of loops.
  2.    Copyright (C) 1987, 1988, 1989 Free Software Foundation, Inc.
  3.  
  4.    $Id: loop.c,v 1.23 92/05/27 10:54:42 pete Exp $ 
  5.  
  6. This file is part of GNU CC.
  7.  
  8. GNU CC is free software; you can redistribute it and/or modify
  9. it under the terms of the GNU General Public License as published by
  10. the Free Software Foundation; either version 1, or (at your option)
  11. any later version.
  12.  
  13. GNU CC is distributed in the hope that it will be useful,
  14. but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. GNU General Public License for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with GNU CC; see the file COPYING.  If not, write to
  20. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21.  
  22.  
  23. /* This is the loop optimization pass of the compiler.
  24.    It finds invariant computations within loops and moves them
  25.    to the beginning of the loop.  Then it identifies basic and 
  26.    general induction variables.  Strength reduction is applied to the general
  27.    induction variables, and induction variable elimination is applied to
  28.    the basic induction variables.
  29.  
  30.    It also finds cases where
  31.    a register is set within the loop by zero-extending a narrower value
  32.    and changes these to zero the entire register once before the loop
  33.    and merely copy the low part within the loop.
  34.  
  35.    Most of the complexity is in heuristics to decide when it is worth
  36.    while to do these things.  */
  37.  
  38. /* ??? verify_loop would run faster if we made one table
  39.    of the minimum and maximum luids from which each label is reached.
  40.    Also, it would be faster if loop_store_addrs were a hash table.  */
  41.  
  42. #include "config.h"
  43. #include "rtl.h"
  44. #include "expr.h"
  45. #if ! defined( _INTELC32_ )
  46. #include "insn-config.h"
  47. #else
  48. #include "iconfig.h"
  49. #endif
  50. #include "regs.h"
  51. #if ! defined( _INTELC32_ )
  52. #include "hard-reg-set.h"
  53. #else
  54. #include "hardrset.h"
  55. #endif
  56. #include "recog.h"
  57. #include "flags.h"
  58. #include <stdio.h>
  59.  
  60. /* Vector mapping INSN_UIDs to luids.
  61.    The luids are like uids but increase monononically always.
  62.    We use them to see whether a jump comes from outside a given loop.  */
  63.  
  64. static int *uid_luid;
  65.  
  66. /* Get the luid of an insn.  */
  67.  
  68. #define INSN_LUID(INSN) (uid_luid[INSN_UID (INSN)])
  69.  
  70. /* 1 + largest uid of any insn.  */
  71.  
  72. static int max_uid;
  73.  
  74. /* 1 + luid of last insn.  */
  75.  
  76. static int max_luid;
  77.  
  78. /* Nonzero if somewhere in the current loop
  79.    there is either a subroutine call,
  80.    or a store into a memory address that is not fixed,
  81.    or a store in a BLKmode memory operand,
  82.    or too many different fixed addresses stored in
  83.    to record them all in `loop_store_addrs'.
  84.  
  85.    In any of these cases, no memory location can be regarded
  86.    as invariant.  */
  87.  
  88. static int unknown_address_altered;
  89.  
  90. /* Nonzero if somewhere in the current loop there is a store
  91.    into a memory address that is not fixed but is known to be
  92.    part of an aggregate.
  93.  
  94.    In this case, no memory reference in an aggregate may be
  95.    considered invariant.  */
  96.  
  97. static int unknown_aggregate_altered;
  98.  
  99. /* Nonzero if somewhere in the current loop there is a store
  100.    into a memory address other than a fixed address not in an aggregate.
  101.  
  102.    In this case, no memory reference in an aggregate at a varying address
  103.    may be considered invariant.  */
  104.  
  105. static int fixed_aggregate_altered;
  106.  
  107. /* Nonzero if there is a subroutine call in the current loop.
  108.    (unknown_address_altered is also nonzero in this case.)  */
  109.  
  110. static int loop_has_call;
  111.  
  112. /* Added loop_continue which is the NOTE_INSN_LOOP_CONT of the
  113.    current loop.  A continue statement will generate a branch to
  114.    NEXT_INSN (loop_continue).  */
  115.  
  116. static rtx loop_continue;
  117.  
  118. /* Indexed by register number, contains the number of times the reg
  119.    is set during the loop being scanned.
  120.    During code motion, -1 indicates a reg that has been made a candidate.
  121.    After code motion, regs moved have 0 (which is accurate now)
  122.    while the failed candidates have the original number of times set.
  123.  
  124.    Therefore, at all times, 0 indicates an invariant register;
  125.    -1 a conditionally invariant one.  */
  126.  
  127. static short *n_times_set;
  128.  
  129. /* Original value of n_times_set; same except that this value
  130.    is not set to -1 for a reg whose sets have been made candidates
  131.    and not set to 0 for a reg that is moved.  */
  132.  
  133. static short *n_times_used;
  134.  
  135. /* Nonzero means reg N has already been moved out of one loop.
  136.    This reduces the desire to move it out of another.  */
  137.  
  138. static char *moved_once;
  139.  
  140. /* Array of fixed memory addresses that are stored in this loop.
  141.    If there are too many to fit here,
  142.    we just turn on unknown_address_altered.  */
  143.  
  144. #define NUM_STORES 10
  145. static rtx loop_store_addrs[NUM_STORES];
  146. static int loop_store_widths[NUM_STORES];
  147.  
  148. /* Index of first available slot in above array.  */
  149. static int loop_store_addrs_idx;
  150.  
  151. /* Count of movable (i.e. invariant) instructions discovered in the loop.  */
  152. static int num_movables;
  153.  
  154. /* Count of memory write instructions discovered in the loop.  */
  155. static int num_mem_sets;
  156.  
  157. /* Number of loops contained within the current one, including itself.  */
  158. static int loops_enclosed;
  159.  
  160. /* Bound on pseudo register number before loop optimization.
  161.    A pseudo has valid regscan info if its number is < old_max_reg.  */
  162. static int old_max_reg;
  163.  
  164. /* During the analysis of a loop, a chain of `struct movable's
  165.    is made to record all the movable insns found.
  166.    Then the entire chain can be scanned to decide which to move.  */
  167.  
  168. struct movable
  169. {
  170.   rtx insn;            /* A movable insn */
  171.   rtx set_src;                  /* The expression this reg is set from.
  172.                    Either SET_SRC (body) or a REG_EQUAL.  */
  173.   int consec;            /* Number of consecutive following insns 
  174.                    that must be moved with this one.  */
  175.   int regno;            /* The register it sets */
  176.   short lifetime;        /* lifetime of that register;
  177.                    may be adjusted when matching movables
  178.                    that load the same value are found.  */
  179.   short savings;        /* Number of insns we can move for this reg,
  180.                    including other movables that force this
  181.                    or match this one.  */
  182.   unsigned int cond : 1;    /* 1 if only conditionally movable */
  183.   unsigned int force : 1;    /* 1 means MUST move this insn */
  184.   unsigned int global : 1;    /* 1 means reg is live outside this loop */
  185.         /* If PARTIAL is 1, GLOBAL means something different:
  186.            that the reg is live outside the range from where it is set
  187.            to the following label.  */
  188.   unsigned int done : 1;    /* 1 inhibits further processing of this */
  189.   /* 1 in PARTIAL means this reg is used for zero-extending.
  190.      In particular, moving it does not make it invariant.  */
  191.   unsigned int partial : 1;
  192.   enum machine_mode savemode;   /* Nonzero means it is a mode for a low part
  193.                    that we should avoid changing when clearing
  194.                    the rest of the reg.  */
  195.   struct movable *match;    /* First entry for same value */
  196.   struct movable *forces;    /* An insn that must be moved if this is */
  197.   struct movable *next;
  198. };
  199.  
  200. static FILE *loop_dump_stream;
  201.  
  202. /* Forward declarations.  */
  203.  
  204. struct induction;
  205. struct iv_class;
  206.  
  207. #if defined( DSP96000 ) || defined( DSP56000 )
  208. static rtx find_mem ( );
  209. static rtx get_bcond_label ( );
  210. static int const_expr_p ( );
  211. static rtx find_best_equiv ( );
  212. static rtx compute_loop_count ( );
  213. static int reg_really_used_between_p ( );
  214. static int biv_qualified_p ( );
  215. static int no_jumps_out_of_loop_p ( );
  216. static int insn_is_do_p ( );
  217. static int insn_is_od_p ( );
  218. static int pre_existing_test_p ( );
  219. static enum rtx_code flip_cond_code ( );
  220. #endif
  221. static rtx verify_loop ();
  222. static int invariant_p ();
  223. static int consec_sets_invariant_p ();
  224. static int can_jump_into_range_p ();
  225. static int labels_in_range_p ();
  226. static void count_loop_regs_set ();
  227. static void note_addr_stored ();
  228. static int loop_reg_used_before_p ();
  229. static void constant_high_bytes ();
  230. static void scan_loop ();
  231. static rtx replace_regs ();
  232. static void replace_call_address ();
  233. static rtx skip_consec_insns ();
  234. static void ignore_some_movables ();
  235. static void force_movables ();
  236. static void combine_movables ();
  237. static int rtx_equal_for_loop_p ();
  238. static void move_movables ();
  239. static void strength_reduce ();
  240. static void find_mem_givs ();
  241. static void record_giv ();
  242. static void delete_insn_forces ();
  243. static int basic_induction_var ();
  244. static int general_induction_var ();
  245. static int consec_sets_giv ();
  246. static int check_dbra_loop ();
  247. static void emit_iv_init_code ();
  248. static int product_cheap_p ();
  249. static void emit_iv_inc ();
  250. static void check_eliminate_biv ();
  251. static int can_eliminate_biv_p ();
  252. static void eliminate_biv ();
  253. static rtx final_biv_value ();
  254. static int last_use_this_basic_block ();
  255.  
  256. /* Entry point of this file.  Perform loop optimization
  257.    on the current function.  F is the first insn of the function
  258.    and DUMPFILE is a stream for output of a trace of actions taken
  259.    (or 0 if none should be output).  */
  260.  
  261. void
  262. loop_optimize (f, dumpfile)
  263.      /* f is the first instruction of a chain of insns for one function */
  264.      rtx f;
  265.      FILE *dumpfile;
  266. {
  267.   register rtx insn;
  268.   register int i;
  269.   rtx end;
  270.   rtx last_insn;
  271.  
  272.   loop_dump_stream = dumpfile;
  273.  
  274.   init_recog ();
  275.  
  276.   old_max_reg = max_reg_num ();
  277.  
  278.   moved_once = (char *) alloca (old_max_reg);
  279.   bzero (moved_once, old_max_reg);
  280.  
  281.   /* First find the last real insn, and count the number of insns,
  282.      and assign insns their luids.  */
  283.  
  284.   for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
  285.     if (INSN_UID (insn) > i)
  286.       i = INSN_UID (insn);
  287.  
  288.   max_uid = i + 1;
  289.   uid_luid = (int *) alloca ((i + 1) * sizeof (int));
  290.   bzero (uid_luid, (i + 1) * sizeof (int));
  291.  
  292.   /* Compute the mapping from uids to luids.
  293.      LUIDs are numbers assigned to insns, like uids,
  294.      except that luids increase monotonically through the code.
  295.      Don't assign luids to line-number NOTEs, so that the distance in luids
  296.      between two insns is not affected by -g.  */
  297.  
  298.   for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
  299.     {
  300.       last_insn = insn;
  301.       if (GET_CODE (insn) != NOTE
  302.       || NOTE_LINE_NUMBER (insn) < 0)
  303.     INSN_LUID (insn) = ++i;
  304.       else
  305.     /* Give a line number note the same luid as preceding insn.  */
  306.     INSN_LUID (insn) = i;
  307.     }
  308.  
  309.   max_luid = i;
  310.  
  311.   /* Don't leave gaps in uid_luid for insns that have been
  312.      deleted.  It is possible that the first or last insn
  313.      using some register has been deleted by cross-jumping.
  314.      Make sure that uid_luid for that former insn's uid
  315.      points to the general area where that insn used to be.  */
  316.   for (i = 0; i < max_uid; i++)
  317.     {
  318.       uid_luid[0] = uid_luid[i];
  319.       if (uid_luid[0] != 0)
  320.     break;
  321.     }
  322.   for (i = 0; i < max_uid; i++)
  323.     if (uid_luid[i] == 0)
  324.       uid_luid[i] = uid_luid[i - 1];
  325.  
  326.   /* Find and process each loop.
  327.      We scan from the end, and process each loop when its start is seen,
  328.      so we process innermost loops first.  */
  329.  
  330.   for (insn = last_insn; insn; insn = PREV_INSN (insn))
  331.     if (GET_CODE (insn) == NOTE
  332.     && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
  333.       {
  334.     /* Make sure it really is a loop -- no jumps in from outside.  */
  335.     end = verify_loop (f, insn);
  336.     if (end != 0)
  337.       /* If so, optimize this loop.  */
  338.       scan_loop (insn, end, max_reg_num ());
  339.     else if (loop_dump_stream)
  340.       fprintf (loop_dump_stream,
  341.            "\nLoop at %d ignored due to multiple entry points.\n",
  342.            INSN_UID (insn));
  343.       }
  344. }
  345.  
  346. /* Optimize one loop whose start is LOOP_START and end is END.
  347.    LOOP_START is the NOTE_INSN_LOOP_BEG and END is the matching
  348.    NOTE_INSN_LOOP_END.  */
  349.  
  350. /* ??? can also move memory writes out of loop if destination
  351.    address is invariant? */
  352.  
  353. static void
  354. scan_loop (loop_start, end, nregs)
  355.      rtx loop_start, end;
  356.      int nregs;
  357. {
  358.   register int i;
  359.   register rtx p = NEXT_INSN (loop_start);
  360.   /* 1 if we are scanning insns that could be executed zero times.  */
  361.   int maybe_never = 0;
  362.   /* 1 if we are scanning insns that might never be executed
  363.      due to a subroutine call which might exit before they are reached.  */
  364.   int call_passed = 0;
  365.   /* For a rotated loop that is entered near the bottom,
  366.      this is the label at the top.  Otherwise it is zero.  */
  367.   rtx loop_top = 0;
  368.   /* Jump insn that enters the loop, or 0 if control drops in.  */
  369.   rtx loop_entry_jump = 0;
  370.   /* Place in the loop where control enters.  */
  371.   rtx scan_start;
  372.   /* Number of insns in the loop.  */
  373.   int insn_count;
  374.   int tem;
  375.   rtx temp;
  376.   /* Indexed by register number, contains 1 for a register whose
  377.      assignments may not be moved out of the loop.  */
  378.   char *may_not_move;
  379.   /* Chain describing insns movable in current loop.  */
  380.   struct movable *movables = 0;
  381.   /* Last element in `movables' -- so we can add elements at the end.  */
  382.   struct movable *last_movable = 0;
  383.   /* Ratio of extra register life span we can justify
  384.      for saving an instruction.  More if loop doesn't call subroutines
  385.      since in that case saving an insn makes more difference
  386.      and more registers are available.  */
  387. #if defined( DSP56000 ) || defined( DSP96000 )
  388.   /* for our dsp chips, this linv movement scoring mechanism is bad.
  389.    * some movables are more important than others because they can gate
  390.    * things like array strength reduction and do loop generation. we
  391.    * have decided to pay the register lifetime penalty to float most
  392.    * invariants out. this area needs more work.
  393.    */
  394.   int threshold = loop_has_call ? 50 : 100;
  395. #else
  396.   int threshold = loop_has_call ? 15 : 30;
  397. #endif
  398.   /* Nonzero if the insn that jumps into the real loop
  399.      is not the very first thing after the loop-beginning note.  */
  400.   int something_before_entry_jump = 0;
  401.  
  402.   n_times_set = (short *) alloca (nregs * sizeof (short));
  403.   n_times_used = (short *) alloca (nregs * sizeof (short));
  404.   may_not_move = (char *) alloca (nregs);
  405.  
  406.   /* Determine whether this loop starts with a jump down
  407.      to a test at the end.  */
  408.   while (p != end
  409.      && GET_CODE (p) != CODE_LABEL && GET_CODE (p) != JUMP_INSN)
  410.     {
  411.       if (GET_CODE (p) == CALL_INSN || GET_CODE (p) == INSN)
  412.     something_before_entry_jump = 1;
  413.       p = NEXT_INSN (p);
  414.     }
  415.  
  416.   /* "Loop" contains neither jumps nor labels;
  417.      it must have been a dummy.  Think no more about it.  */
  418.   if (p == end)
  419.     return;
  420.  
  421.   scan_start = p;
  422.  
  423.   /* If loop has a jump before the first label,
  424.      the true entry is the target of that jump.
  425.      Start scan from there.
  426.      But record in LOOP_TOP the place where the end-test jumps
  427.      back to so we can scan that after the end of the loop.  */
  428.   if (GET_CODE (p) == JUMP_INSN)
  429.     {
  430.       loop_entry_jump = p;
  431.       loop_top = NEXT_INSN (p);
  432.       /* Loop entry will never be a conditional jump.
  433.      If we see one, this must not be a real loop.
  434.      Also, a return-insn isn't a jump to enter the loop.  */
  435.       if (GET_CODE (loop_top) != BARRIER
  436.       || GET_CODE (PATTERN (p)) != SET)
  437.     return;
  438.       /* Get the label at which the loop is entered.  */
  439.       p = XEXP (SET_SRC (PATTERN (p)), 0);
  440.       /* Check to see whether the jump actually
  441.      jumps out of the loop (meaning it's no loop).
  442.      This case can happen for things like
  443.      do {..} while (0).  */
  444.       if (p == 0
  445.       || INSN_LUID (p) < INSN_LUID (loop_start)
  446.       || INSN_LUID (p) >= INSN_LUID (end))
  447.     {
  448.       if (loop_dump_stream)
  449.         fprintf (loop_dump_stream, "\nLoop from %d to %d is phony.\n\n",
  450.              INSN_UID (loop_start), INSN_UID (end));
  451.       return;
  452.     }
  453.  
  454.       /* Find the first label after the entry-jump.  */
  455.       while (GET_CODE (loop_top) != CODE_LABEL)
  456.     {
  457.       loop_top = NEXT_INSN (loop_top);
  458.       if (loop_top == 0)
  459.         abort ();
  460.     }
  461.  
  462.       /* Maybe rearrange the loop to drop straight in
  463.      with a new test to jump around it entirely.
  464.      (The latter is considered outside the loop.)
  465.      If this is done, we no longer enter with a jump.  */
  466.       if (! something_before_entry_jump
  467.       && loop_skip_over (loop_start, end, loop_entry_jump))
  468.     {
  469.       scan_start = loop_top;
  470.       loop_top = 0;
  471.     }
  472.       else
  473.     /* We really do enter with a jump;
  474.        scan the loop from the place where the jump jumps to.  */
  475.     scan_start = p;
  476.     }
  477.  
  478.   /* Count number of times each reg is set during this loop.
  479.      Set MAY_NOT_MOVE[I] if it is not safe to move out
  480.      the setting of register I.  */
  481.  
  482.   bzero (n_times_set, nregs * sizeof (short));
  483.   bzero (may_not_move, nregs);
  484.   count_loop_regs_set (loop_top ? loop_top : loop_start, end,
  485.                may_not_move, &insn_count, nregs);
  486.   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
  487.     may_not_move[i] = 1, n_times_set[i] = 1;
  488.   bcopy (n_times_set, n_times_used, nregs * sizeof (short));
  489.  
  490.   if (loop_dump_stream)
  491.     {
  492.       fprintf (loop_dump_stream, "\nLoop from %d to %d: %d real insns.\n",
  493.            INSN_UID (loop_start), INSN_UID (end), insn_count);
  494.       if (loop_continue)
  495.     fprintf (loop_dump_stream, "Continue at insn %d.\n",
  496.          INSN_UID (loop_continue));
  497.     }
  498.  
  499.   /* Scan through the loop finding insns that are safe to move.
  500.      In each such insn, store QImode as the mode, to mark it.
  501.      Then set n_times_set to -1 for the reg being set, so that
  502.      this reg will be considered invariant for subsequent insns.
  503.      We consider whether subsequent insns use the reg
  504.      in deciding whether it is worth actually moving.
  505.  
  506.      MAYBE_NEVER is nonzero if we have passed a conditional jump insn
  507.      and therefore it is possible that the insns we are scanning
  508.      would never be executed.  At such times, we must make sure
  509.      that it is safe to execute the insn once instead of zero times.
  510.      When MAYBE_NEVER is 0, all insns will be executed at least once
  511.      so that is not a problem.  */
  512.  
  513.   p = scan_start;
  514.   while (1)
  515.     {
  516.       p = NEXT_INSN (p);
  517.       /* At end of a straight-in loop, we are done.
  518.      At end of a loop entered at the bottom, scan the top.  */
  519.       if (p == scan_start)
  520.     break;
  521.       if (p == end)
  522.     {
  523.       if (loop_top != 0)
  524.         p = NEXT_INSN (loop_top);
  525.       else
  526.         break;
  527.       if (p == scan_start)
  528.         break;
  529.     }
  530.       if (GET_CODE (p) == INSN
  531.       && GET_CODE (PATTERN (p)) == SET
  532.       && GET_CODE (SET_DEST (PATTERN (p))) == REG
  533.       && ! may_not_move[REGNO (SET_DEST (PATTERN (p)))])
  534.     {
  535.       int tem1 = 0;
  536.       /* Don't try to optimize a register that was made
  537.          by loop-optimization for an inner loop.
  538.          We don't know its life-span, so we can't compute the benefit.  */
  539.       if (REGNO (SET_DEST (PATTERN (p))) >= old_max_reg)
  540.         ;
  541.       /* If this register is used or set outside the loop,
  542.          then we can move it only if we know this insn is
  543.          executed exactly once per iteration,
  544.          and we can check all the insns executed before it
  545.          to make sure none of them used the value that
  546.          was lying around at entry to the loop.  */
  547.       else if ((uid_luid[regno_last_uid[REGNO (SET_DEST (PATTERN (p)))]] > INSN_LUID (end)
  548.             || uid_luid[regno_first_uid[REGNO (SET_DEST (PATTERN (p)))]] < INSN_LUID (loop_start))
  549.            && (maybe_never
  550.                || loop_reg_used_before_p (p, loop_start, scan_start, end)))
  551.         ;
  552.       else if (((tem = invariant_p (SET_SRC (PATTERN (p))))
  553.             || ((temp = find_reg_note (p, REG_EQUAL, 0)) 
  554.             && (tem = invariant_p (XEXP (temp, 0)))))
  555.            && (n_times_set[REGNO (SET_DEST (PATTERN (p)))] == 1
  556.                || (tem1
  557.                = consec_sets_invariant_p (SET_DEST (PATTERN (p)),
  558.                               n_times_set[REGNO (SET_DEST (PATTERN (p)))],
  559.                               p)))
  560.            /* If the insn can cause a trap (such as divide by zero),
  561.               can't move it unless it's guaranteed to be executed
  562.               once loop is entered.  Even a function call might
  563.               prevent the trap insn from being reached
  564.               (since it might exit!)  */
  565.            && ! ((maybe_never || call_passed)
  566.              && (may_trap_p (SET_SRC (PATTERN (p)))
  567.                  || ((temp = find_reg_note (p, REG_EQUAL, 0))
  568.                  && may_trap_p (XEXP (temp, 0))))))
  569.         {
  570.           register struct movable *m;
  571.           register int regno = REGNO (SET_DEST (PATTERN (p)));
  572.           int count;
  573.           m = (struct movable *) alloca (sizeof (struct movable));
  574.           m->next = 0;
  575.           m->insn = p;
  576.           temp = find_reg_note (p, REG_EQUAL, 0);
  577.           if (temp)
  578.         m->set_src = XEXP (temp, 0);
  579.           else
  580.         m->set_src = SET_SRC (PATTERN (p));
  581.           m->force = 0;
  582.           m->consec = n_times_set[REGNO (SET_DEST (PATTERN (p)))] - 1;
  583.           m->done = 0;
  584.           m->forces = 0;
  585.           m->partial = 0;
  586.           m->savemode = VOIDmode;
  587.           m->regno = regno;
  588.           /* Set M->cond if either invariant_p or consec_sets_invariant_p
  589.          returned 2 (only conditionally invariant).  */
  590.           m->cond = ((tem | tem1) > 1);
  591.           m->global = (uid_luid[regno_last_uid[regno]] > INSN_LUID (end)
  592.                || uid_luid[regno_first_uid[regno]] < INSN_LUID (loop_start));
  593.           m->match = 0;
  594.           m->lifetime = (uid_luid[regno_last_uid[regno]]
  595.                  - uid_luid[regno_first_uid[regno]]);
  596.           m->savings = n_times_used[regno];
  597.           n_times_set[regno] = -1;
  598.           /* Add M to the end of the chain MOVABLES.  */
  599.           if (movables == 0)
  600.         movables = m;
  601.           else
  602.         last_movable->next = m;
  603.           last_movable = m;
  604.           if (m->consec > 0)
  605.         {
  606.           /* Skip this insn, not checking REG_LIBCALL notes.  */
  607.           p = NEXT_INSN (p);
  608.           /* Skip the consecutive insns, if there are any.  */
  609.           p = skip_consec_insns (p, m->consec);
  610.           /* Back up, so the main loop will advance to the right place.  */
  611.           p = PREV_INSN (p);
  612.         }
  613.         }
  614.       /* If this register is always set within a STRICT_LOW_PART
  615.          or set to zero, then its high bytes are constant.
  616.          So clear them outside the loop and within the loop
  617.          just load the low bytes.
  618.          We must check that the machine has an instruction to do so.
  619.          Also, if the value loaded into the register
  620.          depends on the same register, this cannot be done.  */
  621.       else if (SET_SRC (PATTERN (p)) == const0_rtx
  622.            && GET_CODE (NEXT_INSN (p)) == INSN
  623.            && GET_CODE (PATTERN (NEXT_INSN (p))) == SET
  624.            && (GET_CODE (SET_DEST (PATTERN (NEXT_INSN (p))))
  625.                == STRICT_LOW_PART)
  626.            && (GET_CODE (XEXP (SET_DEST (PATTERN (NEXT_INSN (p))), 0))
  627.                == SUBREG)
  628.            && (SUBREG_REG (XEXP (SET_DEST (PATTERN (NEXT_INSN (p))), 0))
  629.                == SET_DEST (PATTERN (p)))
  630.            && !reg_mentioned_p (SET_DEST (PATTERN (p)),
  631.                     SET_SRC (PATTERN (NEXT_INSN (p)))))
  632.         {
  633.           register int regno = REGNO (SET_DEST (PATTERN (p)));
  634.           if (n_times_set[regno] == 2)
  635.         {
  636.           register struct movable *m;
  637.           int count;
  638.           m = (struct movable *) alloca (sizeof (struct movable));
  639.           m->next = 0;
  640.           m->insn = p;
  641.           m->force = 0;
  642.           m->consec = 0;
  643.           m->done = 0;
  644.           m->forces = 0;
  645.           m->partial = 1;
  646.           /* If the insn may not be executed on some cycles,
  647.              we can't clear the whole reg; clear just high part.
  648.              Not even if the reg is used only within this loop.
  649.              Consider this:
  650.              while (1)
  651.                while (s != t) {
  652.                  if (foo ()) x = *s;
  653.              use (x);
  654.                }
  655.              Clearing x before the inner loop could clobber a value
  656.              being saved from the last time around the outer loop.
  657.              However, if the reg is not used outside this loop
  658.              and all uses of the register are in the same
  659.              basic block as the store, there is no problem.  */
  660.           m->global = (uid_luid[regno_last_uid[regno]] > INSN_LUID (end)
  661.                    || uid_luid[regno_first_uid[regno]] < INSN_LUID (p)
  662.                    || (labels_in_range_p
  663.                    (p, uid_luid[regno_first_uid[regno]])));
  664.           if (maybe_never && m->global)
  665.             m->savemode = GET_MODE (SET_SRC (PATTERN (NEXT_INSN (p))));
  666.           else
  667.             m->savemode = VOIDmode;
  668.           m->regno = regno;
  669.           m->cond = 0;
  670.           m->match = 0;
  671.           m->lifetime = (uid_luid[regno_last_uid[regno]]
  672.                  - uid_luid[regno_first_uid[regno]]);
  673.           m->savings = 1;
  674.           n_times_set[regno] = -1;
  675.           /* Add M to the end of the chain MOVABLES.  */
  676.           if (movables == 0)
  677.             movables = m;
  678.           else
  679.             last_movable->next = m;
  680.           last_movable = m;
  681.         }
  682.         }
  683.     }
  684.       /* Past a call insn, we get to insns which might not be executed
  685.      because the call might exit.  This matters for insns that trap.  */
  686.       else if (GET_CODE (p) == CALL_INSN)
  687.     call_passed = 1;
  688.       /* Past a label or a jump, we get to insns for which we
  689.      can't count on whether or how many times they will be
  690.      executed during each iteration.  Therefore, we can
  691.      only move out sets of trivial variables
  692.      (those not used after the loop).  */
  693.       else if ((GET_CODE (p) == CODE_LABEL || GET_CODE (p) == JUMP_INSN)
  694.            /* If we enter the loop in the middle, and scan around
  695.           to the beginning, don't set maybe_never for that.  */
  696.                && ! (NEXT_INSN (p) == end && GET_CODE (p) == JUMP_INSN
  697.                      && simplejump_p (p)))
  698.     maybe_never = 1;
  699.     }
  700.  
  701.   /* If one movable subsumes another, ignore that other.  */
  702.  
  703.   ignore_some_movables (movables);
  704.  
  705.   /* For each movable insn, see if the reg that it loads
  706.      leads when it dies right into another conditionally movable insn.
  707.      If so, record that the second insn "forces" the first one,
  708.      since the second can be moved only if the first is.  */
  709.  
  710.   force_movables (movables);
  711.  
  712.   /* See if there are multiple movable insns that load the same value.
  713.      If there are, make all but the first point at the first one
  714.      through the `match' field, and add the priorities of them
  715.      all together as the priority of the first.  */
  716.  
  717.   combine_movables (movables, nregs);
  718.     
  719.   /* Now consider each movable insn to decide whether it is worth moving.
  720.      Store 0 in n_times_set for each reg that is moved.  */
  721.  
  722.   move_movables (movables, threshold,
  723.          insn_count, loop_start, end, nregs);
  724.  
  725.   /* Now candidates that still have -1 are those not moved.
  726.      Change n_times_set to indicate that those are not actually invariant.  */
  727.   for (i = 0; i < nregs; i++)
  728.     if (n_times_set[i] < 0)
  729.       n_times_set[i] = n_times_used[i];
  730.  
  731.   if (flag_strength_reduce)
  732.     strength_reduce (scan_start, end, loop_top,
  733.              insn_count, loop_start, end, nregs);
  734. }
  735.  
  736. /* Skip COUNT insns from INSN, counting library calls as 1 insn.  */
  737.  
  738. static rtx
  739. skip_consec_insns (insn, count)
  740.      rtx insn;
  741.      int count;
  742. {
  743.   for (; count > 0; count--)
  744.     {
  745.       if (GET_CODE (insn) == NOTE)
  746.     insn = NEXT_INSN (insn);
  747.       else if (GET_CODE (insn) == BARRIER || GET_CODE (insn) == CODE_LABEL)
  748.     abort ();
  749.       else
  750.     {
  751.       rtx i1, temp;
  752.  
  753.       /* If first insn of gnulib call sequence, skip to end.  */
  754.       /* Do this at start of loop, since INSN is guaranteed to 
  755.          be an insn here.  */
  756.       if (temp = find_reg_note (insn, REG_LIBCALL, 0))
  757.         insn = XEXP (temp, 0);
  758.  
  759.       do insn = NEXT_INSN (insn);
  760.       while (GET_CODE (insn) == NOTE);
  761.     }
  762.     }
  763.  
  764.   return insn;
  765. }
  766.  
  767. /* Ignore any movable whose insn falls within a libcall
  768.    which is part of another movable.
  769.    We make use of the fact that the movable for the libcall value
  770.    was made later and so appears later on the chain.  */
  771.  
  772. static void
  773. ignore_some_movables (movables)
  774.      struct movable *movables;
  775. {
  776.   register struct movable *m, *m1;
  777.  
  778. #if defined( DSP56000 ) || defined( DSP96000 )
  779.   /* This REG_LIBCALL thing doesn't fit well with the movables concept.
  780.    * This change blows away movables that have REG_LIBCALL affixed.
  781.    * Later passes of the depend on REG_LIBCALL / REG_RETVAL sequences
  782.    * remaining intact. If we move an insn with REG_LIBCALL affixed out
  783.    * of the loop we open a Pandora's box. If we shift the 
  784.    * REG_LIBCALL onto the following insn then we create another
  785.    * problem: if the original REG_LIBCALL insn isn't moved out
  786.    * of the loop, and the new REG_LIBCALL / REG_RETVAL sequence
  787.    * is, then part of the call setup will not be performed.
  788.    * Our solution, for now, is to disallow the movement of 
  789.    * a REG_LIBCALL annotated insn.
  790.    */
  791. #endif
  792.   for (m = movables; m; m = m->next)
  793.     {
  794.       /* Is this a movable for the value of a libcall?  */
  795.       rtx note = find_reg_note (m->insn, REG_RETVAL, 0);
  796.       if (note)
  797.     {
  798.       /* Find the beginning of that libcall.  */
  799.       rtx first_insn = XEXP (note, 0);
  800.       /* Check for earlier movables inside that range,
  801.          and mark them invalid.  */
  802.       for (m1 = movables; m1 != m; m1 = m1->next)
  803.         if (INSN_LUID (m1->insn) >= INSN_LUID (first_insn)
  804.         && INSN_LUID (m1->insn) < INSN_LUID (m->insn))
  805.           m1->done = 1;
  806.     }
  807. #if defined( DSP56000 ) || defined( DSP96000 )
  808.       else if ( find_reg_note ( m->insn, REG_LIBCALL, 0 ))
  809.     {
  810.         m->done = 1;
  811.     }
  812. #endif
  813.     }
  814. }      
  815.  
  816. /* For each movable insn, see if the reg that it loads
  817.    leads when it dies right into another conditionally movable insn.
  818.    If so, record that the second insn "forces" the first one,
  819.    since the second can be moved only if the first is.  */
  820.  
  821. static void
  822. force_movables (movables)
  823.      struct movable *movables;
  824. {
  825.   register struct movable *m, *m1;
  826.   for (m1 = movables; m1; m1 = m1->next)
  827.     /* Omit this if moving just the (SET (REG) 0) of a zero-extend.  */
  828.     if (!m1->partial && !m1->done)
  829.       {
  830.     int regno = m1->regno;
  831.     for (m = m1->next; m; m = m->next)
  832.       /* ??? Could this be a bug?  What if CSE caused the
  833.          register of M1 to be used after this insn?
  834.          Since CSE does not update regno_last_uid,
  835.          this insn M->insn might not be where it dies.
  836.          But very likely this doesn't matter; what matters is
  837.          that M's reg is computed from M1's reg.  */
  838.       if (INSN_UID (m->insn) == regno_last_uid[regno]
  839.           && !m->done)
  840.         break;
  841.     if (m != 0 && m->set_src == SET_DEST (PATTERN (m1->insn)))
  842.       m = 0;
  843.  
  844.     /* Increase the priority of the moving the first insn
  845.        since it permits the second to be moved as well.  */
  846.     if (m != 0)
  847.       {
  848.         m->forces = m1;
  849.         m1->lifetime += m->lifetime;
  850.         m1->savings += m1->savings;
  851.       }
  852.       }
  853. }
  854.  
  855. /* Find invariant expressions that are equal and can be combined into
  856.    one register.  */
  857.  
  858. static void
  859. combine_movables (movables, nregs)
  860.      struct movable *movables;
  861.      int nregs;
  862. {
  863.   register struct movable *m;
  864.   char *matched_regs = (char *) alloca (nregs);
  865.   enum machine_mode mode;
  866.  
  867.   /* Regs that are set more than once are not allowed to match
  868.      or be matched.  I'm no longer sure why not.  */
  869.   /* Perhaps testing m->consec_sets would be more appropriate here?  */
  870.  
  871.   for (m = movables; m; m = m->next)
  872.     if (m->match == 0 && n_times_used[m->regno] == 1 && !m->partial)
  873.       {
  874.     register struct movable *m1;
  875.     int regno = m->regno;
  876.  
  877.     bzero (matched_regs, nregs);
  878.     matched_regs[regno] = 1;
  879.  
  880.     for (m1 = m->next; m1; m1 = m1->next)
  881.       if (m1->match == 0 && n_times_used[m1->regno] == 1
  882.           /* A reg used outside the loop mustn't be eliminated.  */
  883.           && !m1->global
  884.           /* A reg used for zero-extending mustn't be eliminated.  */
  885.           && !m1->partial
  886.           && (matched_regs[m1->regno]
  887.           ||
  888.           (
  889.            /* Can't combine regs with different modes
  890.               even if loaded from the same constant.  */
  891.            (GET_MODE (SET_DEST (PATTERN (m->insn)))
  892.             == GET_MODE (SET_DEST (PATTERN (m1->insn))))
  893.            /* See if the source of M1 says it matches M.  */
  894.            && ((GET_CODE (m1->set_src) == REG
  895.             && matched_regs[REGNO (m1->set_src)])
  896.                || rtx_equal_for_loop_p (m->set_src, m1->set_src,
  897.                         movables)
  898.                || (REG_NOTES (m->insn) && REG_NOTES (m1->insn)
  899.                && REG_NOTE_KIND (REG_NOTES (m->insn)) == REG_EQUIV
  900.                && REG_NOTE_KIND (REG_NOTES (m1->insn)) == REG_EQUIV
  901.                && rtx_equal_p (XEXP (REG_NOTES (m->insn), 0),
  902.                        XEXP (REG_NOTES (m1->insn), 0)))))))
  903.         {
  904.           m->lifetime += m1->lifetime;
  905.           m->savings += m1->savings;
  906.           m1->match = m;
  907.           matched_regs[m1->regno] = 1;
  908.         }
  909.       }
  910.  
  911.   /* Now combine the regs used for zero-extension.
  912.      This can be done for those not marked `global'
  913.      provided their lives don't overlap.  */
  914.  
  915.   for (mode = VOIDmode; (int) mode < (int) MAX_MACHINE_MODE;
  916.        mode = (enum machine_mode) ((int) mode + 1))
  917.     if (GET_MODE_CLASS (mode) == MODE_INT)
  918.       {
  919.     register struct movable *m0 = 0;
  920.  
  921.     /* Combine all the registers for extension from mode MODE.
  922.        Don't combine any that are used outside this loop.  */
  923.     for (m = movables; m; m = m->next)
  924.       if (m->partial && ! m->global
  925.           && mode == GET_MODE (SET_SRC (PATTERN (NEXT_INSN (m->insn)))))
  926.         {
  927.           register struct movable *m1;
  928.           int first = uid_luid[regno_first_uid[m->regno]];
  929.           int last = uid_luid[regno_last_uid[m->regno]];
  930.  
  931.           if (m0 == 0)
  932.         {
  933.           /* First one: don't check for overlap, just record it.  */
  934.           m0 = m;
  935.           continue;
  936.         }
  937.  
  938.           /* Make sure they extend to the same mode.
  939.          (Almost always true.)  */
  940.           if (GET_MODE (SET_DEST (PATTERN (m->insn)))
  941.           != GET_MODE (SET_DEST (PATTERN (m0->insn))))
  942.         continue;
  943.  
  944.           /* We already have one: check for overlap with those
  945.          already combined together.  */
  946.           for (m1 = movables; m1 != m; m1 = m1->next)
  947.         if (m1 == m0 || (m1->partial && m1->match == m0))
  948.           if (! (uid_luid[regno_first_uid[m1->regno]] > last
  949.              || uid_luid[regno_last_uid[m1->regno]] < first))
  950.             goto overlap;
  951.  
  952.           /* No overlap: we can combine this with the others.  */
  953.           m0->lifetime += m->lifetime;
  954.           m0->savings += m->savings;
  955.           m->match = m0;
  956.  
  957.         overlap: ;
  958.         }
  959.       }
  960. }
  961.  
  962. /* Return 1 if regs X and Y will become the same if moved.  */
  963.  
  964. static int
  965. regs_match_p (x, y, movables)
  966.      rtx x, y;
  967.      struct movable *movables;
  968. {
  969.   int xn = REGNO (x);
  970.   int yn = REGNO (y);
  971.   struct movable *mx, *my;
  972.  
  973.   for (mx = movables; mx; mx = mx->next)
  974.     if (mx->regno == xn)
  975.       break;
  976.  
  977.   for (my = movables; my; my = my->next)
  978.     if (my->regno == yn)
  979.       break;
  980.  
  981.   return (mx && my
  982.       && ((mx->match == my->match && mx->match != 0)
  983.           || mx->match == my
  984.           || mx == my->match));
  985. }
  986.  
  987. /* Return 1 if X and Y are identical-looking rtx's.
  988.    This is the Lisp function EQUAL for rtx arguments.  */
  989.  
  990. static int
  991. rtx_equal_for_loop_p (x, y, movables)
  992.      rtx x, y;
  993.      struct movable *movables;
  994. {
  995.   register int i;
  996.   register int j;
  997.   register enum rtx_code code;
  998.   register char *fmt;
  999.  
  1000.   if (x == y)
  1001.     return 1;
  1002.   if (x == 0 || y == 0)
  1003.     return 0;
  1004.  
  1005.   code = GET_CODE (x);
  1006.   /* Rtx's of different codes cannot be equal.  */
  1007.   if (code != GET_CODE (y))
  1008.     return 0;
  1009.  
  1010.   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
  1011.      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
  1012.  
  1013.   if (GET_MODE (x) != GET_MODE (y))
  1014.     return 0;
  1015.  
  1016.   /* These three types of rtx's can be compared nonrecursively.  */
  1017.   /* Until the end of reload,
  1018.      don't consider the a reference to the return register of the current
  1019.      function the same as the return from a called function.  This eases
  1020.      the job of function integration.  Once the distinction no longer
  1021.      matters, the insn will be deleted.  */
  1022.   if (code == REG)
  1023.     return ((REGNO (x) == REGNO (y)
  1024.          && REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y))
  1025.         || regs_match_p (x, y, movables));
  1026.  
  1027.   if (code == LABEL_REF)
  1028.     return XEXP (x, 0) == XEXP (y, 0);
  1029.   if (code == SYMBOL_REF)
  1030.     return XSTR (x, 0) == XSTR (y, 0);
  1031.  
  1032.   /* Compare the elements.  If any pair of corresponding elements
  1033.      fail to match, return 0 for the whole things.  */
  1034.  
  1035.   fmt = GET_RTX_FORMAT (code);
  1036.   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
  1037.     {
  1038.       switch (fmt[i])
  1039.     {
  1040.     case 'i':
  1041.       if (XINT (x, i) != XINT (y, i))
  1042.         return 0;
  1043.       break;
  1044.  
  1045.     case 'E':
  1046.       /* Two vectors must have the same length.  */
  1047.       if (XVECLEN (x, i) != XVECLEN (y, i))
  1048.         return 0;
  1049.  
  1050.       /* And the corresponding elements must match.  */
  1051.       for (j = 0; j < XVECLEN (x, i); j++)
  1052.         if (rtx_equal_for_loop_p (XVECEXP (x, i, j), XVECEXP (y, i, j), movables) == 0)
  1053.           return 0;
  1054.       break;
  1055.  
  1056.     case 'e':
  1057.       if (rtx_equal_for_loop_p (XEXP (x, i), XEXP (y, i), movables) == 0)
  1058.         return 0;
  1059.       break;
  1060.  
  1061.     case 's':
  1062.       if (strcmp (XSTR (x, i), XSTR (y, i)))
  1063.         return 0;
  1064.       break;
  1065.  
  1066.     case 'u':
  1067.       /* These are just backpointers, so they don't matter.  */
  1068.       break;
  1069.  
  1070.     case '0':
  1071.       break;
  1072.  
  1073.       /* It is believed that rtx's at this level will never
  1074.          contain anything but integers and other rtx's,
  1075.          except for within LABEL_REFs and SYMBOL_REFs.  */
  1076.     default:
  1077.       abort ();
  1078.     }
  1079.     }
  1080.   return 1;
  1081. }
  1082.  
  1083. /* Scan MOVABLES, and move the insns that deserve to be moved.
  1084.    If two matching movables are combined, replace one reg with the
  1085.    other throughout.  */
  1086.  
  1087. static void
  1088. move_movables (movables, threshold, insn_count, loop_start, end, nregs)
  1089.      struct movable *movables;
  1090.      int threshold;
  1091.      int insn_count;
  1092.      rtx loop_start;
  1093.      rtx end;
  1094.      int nregs;
  1095. {
  1096.   rtx new_start = 0;
  1097.   register struct movable *m;
  1098.   register rtx p;
  1099.   /* Map of pseudo-register replacements to handle combining
  1100.      when we move several insns that load the same value
  1101.      into different pseudo-registers.  */
  1102.   rtx *reg_map = (rtx *) alloca (nregs * sizeof (rtx));
  1103.   char *already_moved = (char *) alloca (nregs);
  1104.  
  1105.   bzero (already_moved, nregs);
  1106.   bzero (reg_map, nregs * sizeof (rtx));
  1107.  
  1108.   num_movables = 0;
  1109.  
  1110.   for (m = movables; m; m = m->next)
  1111.     {
  1112.       /* Describe this movable insn.  */
  1113.  
  1114.       if (loop_dump_stream)
  1115.     {
  1116.       fprintf (loop_dump_stream, "Insn %d: regno %d (life %d), ",
  1117.            INSN_UID (m->insn), m->regno, m->lifetime);
  1118.       if (m->consec > 0)
  1119.         fprintf (loop_dump_stream, "consec %d, ", m->consec);
  1120.       if (m->cond)
  1121.         fprintf (loop_dump_stream, "cond ");
  1122.       if (m->force)
  1123.         fprintf (loop_dump_stream, "force ");
  1124.       if (m->global)
  1125.         fprintf (loop_dump_stream, "global ");
  1126.       if (m->done)
  1127.         fprintf (loop_dump_stream, "done ");
  1128.       if (m->match)
  1129.         fprintf (loop_dump_stream, "matches %d ",
  1130.              INSN_UID (m->match->insn));
  1131.       if (m->forces)
  1132.         fprintf (loop_dump_stream, "forces %d ",
  1133.              INSN_UID (m->forces->insn));
  1134.     }
  1135.  
  1136.       /* Count movables.  Value used in heuristics in strength_reduce.  */
  1137.       num_movables++;
  1138.  
  1139.       /* Ignore the insn if it's already done (it matched something else).
  1140.      Otherwise, see if it is now safe to move.  */
  1141.  
  1142.       if (!m->done
  1143.       && (! m->cond
  1144.           || (1 == invariant_p (m->set_src)
  1145.           && (m->consec == 0
  1146.               || 1 == consec_sets_invariant_p (SET_DEST (PATTERN (m->insn)),
  1147.                                m->consec + 1,
  1148.                                m->insn))))
  1149.       && (! m->forces || m->forces->done))
  1150.     {
  1151.       register int regno;
  1152.       register rtx p;
  1153.       int savings = m->savings;
  1154.  
  1155.       /* We have an insn that is safe to move.
  1156.          Compute its desirability.  */
  1157.  
  1158.       p = m->insn;
  1159.       regno = m->regno;
  1160.  
  1161.       if (loop_dump_stream)
  1162.         fprintf (loop_dump_stream, "savings %d ", savings);
  1163.  
  1164.       if (moved_once[regno])
  1165.         {
  1166.           insn_count *= 2;
  1167.  
  1168.           if (loop_dump_stream)
  1169.         fprintf (loop_dump_stream, "halved since already moved ");
  1170.         }
  1171.  
  1172.       /* An insn MUST be moved if we already moved something else
  1173.          which is safe only if this one is moved too: that is,
  1174.          if already_moved[REGNO] is nonzero.  */
  1175.  
  1176.       /* An insn is desirable to move if the new lifetime of the
  1177.          register is no more than THRESHOLD times the old lifetime.
  1178.          If it's not desirable, it means the loop is so big
  1179.          that moving won't speed things up much,
  1180.          and it is liable to make register usage worse.  */
  1181.  
  1182.       /* It is also desirable to move if it can be moved at no
  1183.          extra cost because something else was already moved.  */
  1184.  
  1185.       if (already_moved[regno]
  1186.           || (threshold * savings * m->lifetime) >= insn_count
  1187.           || (m->forces && m->forces->done
  1188.           && n_times_used[m->forces->regno] == 1))
  1189.         {
  1190.           int count;
  1191.           register struct movable *m1;
  1192.           rtx first;
  1193.  
  1194.           /* Now move the insns that set the reg.  */
  1195.  
  1196.           for (count = m->consec; count >= 0; count--)
  1197.         {
  1198.           rtx i1, temp;
  1199.  
  1200.           /* If first insn of gnulib call sequence, skip to end.  */
  1201.           /* Do this at start of loop, since p is guaranteed to 
  1202.              be an insn here.  */
  1203.           if (temp = find_reg_note (p, REG_LIBCALL, 0))
  1204.             p = XEXP (temp, 0);
  1205.           
  1206.           /* If last insn of gnulib call sequence, move all
  1207.              insns except the last before the loop.  The last insn is
  1208.              handled in the normal manner.  */
  1209.           if (temp = find_reg_note (p, REG_RETVAL
  1210.                         , 0))
  1211.             {
  1212.               rtx fn_address = 0;
  1213.               rtx fn_reg = 0;
  1214.               first = 0;
  1215.               for (temp = XEXP (temp, 0); temp != p;
  1216.                temp = NEXT_INSN (temp))
  1217.             {
  1218.               rtx body = PATTERN (temp);
  1219.               rtx n;
  1220.               /* Extract the function address from the insn
  1221.                  that loads it into a register.
  1222.                  If this insn was cse'd, we get incorrect code.
  1223.                  So delete it and stick the fn address right
  1224.                  into the call insn.  Since the moved insns
  1225.                  won't be cse'd, that does no harm.  */
  1226.               if (GET_CODE (NEXT_INSN (temp)) == CALL_INSN
  1227.                   && GET_CODE (body) == SET
  1228.                   && GET_CODE (SET_DEST (body)) == REG
  1229.                   && (n = find_reg_note (temp, REG_EQUIV, 0)))
  1230.                 {
  1231.                   fn_reg = SET_SRC (body);
  1232.                   if (GET_CODE (fn_reg) != REG)
  1233.                 fn_reg = SET_DEST (body);
  1234.                   fn_address = XEXP (n, 0);
  1235.                   continue;
  1236.                 }
  1237.               /* We have the call insn.
  1238.                  Substitute the fn address for the reg
  1239.                  that we believe this insn will use.  */
  1240.               if (GET_CODE (temp) == CALL_INSN
  1241.                   && fn_address != 0)
  1242.                 replace_call_address (body, fn_reg, fn_address);
  1243.               if (GET_CODE (temp) == CALL_INSN)
  1244.                 i1 = emit_call_insn_before (body, loop_start);
  1245.               else
  1246.                 i1 = emit_insn_before (body, loop_start);
  1247.               if (first == 0)
  1248.                 first = i1;
  1249.               REG_NOTES (i1) = REG_NOTES (temp);
  1250.               delete_insn (temp);
  1251.             }
  1252.             }
  1253.           if (m->savemode != VOIDmode)
  1254.             {
  1255.               /* P sets REG to zero; but we should clear only the bits
  1256.              that are not covered by the mode m->savemode.  */
  1257.               rtx reg = SET_DEST (PATTERN (p));
  1258.               i1 = emit_insn_before
  1259.             (gen_rtx (SET, VOIDmode, reg,
  1260.                   gen_rtx (AND, GET_MODE (reg),
  1261.                        reg,
  1262.                        gen_rtx (CONST_INT, VOIDmode,
  1263.                             (1 << GET_MODE_BITSIZE (m->savemode)) - 1))),
  1264.              loop_start);
  1265.             }
  1266.           else if (GET_CODE (PATTERN (p)) == CALL_INSN)
  1267.             i1 = emit_call_insn_before (PATTERN (p), loop_start);
  1268.           else
  1269.             i1 = emit_insn_before (PATTERN (p), loop_start);
  1270.  
  1271.           if (new_start == 0)
  1272.             new_start = i1;
  1273.  
  1274.           if (loop_dump_stream)
  1275.             fprintf (loop_dump_stream, " moved to %d", INSN_UID (i1));
  1276.  
  1277.           /* Mark the moved, invariant reg as being equivalent to
  1278.              its constant value.  */
  1279.           REG_NOTES (i1) = REG_NOTES (p);
  1280.           if (REG_NOTES (i1) == 0
  1281.               && ! m->partial /* But not if it's a zero-extend clr. */
  1282.               && ! m->global /* and not if used outside the loop
  1283.                     (since it might get set outside).  */
  1284.               && CONSTANT_P (SET_SRC (PATTERN (p))))
  1285.             REG_NOTES (i1)
  1286.               = gen_rtx (EXPR_LIST, REG_EQUIV,
  1287.                  SET_SRC (PATTERN (p)), REG_NOTES (i1));
  1288.  
  1289.           /* If library call, now fix the REG_NOTES that contain
  1290.              insn pointers, namely REG_LIBCALL on FIRST
  1291.              and REG_RETVAL on I1.  */
  1292.           if (temp = find_reg_note (i1, REG_RETVAL, 0))
  1293.             {
  1294.               XEXP (temp, 0) = first;
  1295.               temp = find_reg_note (first, REG_LIBCALL, 0);
  1296.               XEXP (temp, 0) = i1;
  1297.             }
  1298.  
  1299.           delete_insn (p);
  1300.           do p = NEXT_INSN (p);
  1301.           while (GET_CODE (p) == NOTE);
  1302.         }
  1303.  
  1304.           /* The more regs we move, the less we like moving them.  */
  1305.           threshold -= 3;
  1306.  
  1307.           /* Any other movable that loads the same register
  1308.          MUST be moved.  */
  1309.           already_moved[regno] = 1;
  1310.  
  1311.           /* This reg has been moved out of one loop.  */
  1312.           moved_once[regno] = 1;
  1313.  
  1314.           /* The reg set here is now invariant.  */
  1315.           if (! m->partial)
  1316.         n_times_set[regno] = 0;
  1317.  
  1318.           m->done = 1;
  1319.  
  1320.           /* Change the length-of-life info for the register
  1321.          to say it lives at least the full length of this loop.
  1322.          This will help guide optimizations in outer loops.  */
  1323.  
  1324.           if (uid_luid[regno_first_uid[regno]] > INSN_LUID (loop_start))
  1325.         /* This is the old insn before all the moved insns.
  1326.            We can't use the moved insn because it is out of range
  1327.            in uid_luid.  Only the old insns have luids.  */
  1328.         regno_first_uid[regno] = INSN_UID (loop_start);
  1329.           if (uid_luid[regno_last_uid[regno]] < INSN_LUID (end))
  1330.         regno_last_uid[regno] = INSN_UID (end);
  1331.  
  1332.           /* Combine with this moved insn any other matching movables.  */
  1333.  
  1334.           for (m1 = m->next; m1; m1 = m1->next)
  1335.         if (m1->match == m)
  1336.           {
  1337.             rtx temp;
  1338.  
  1339.             /* Schedule the reg loaded by M1
  1340.                for replacement so that shares the reg of M.  */
  1341.             reg_map[m1->regno] = SET_DEST (PATTERN (m->insn));
  1342.             /* Get rid of the matching insn
  1343.                and prevent further processing of it.  */
  1344.             m1->done = 1;
  1345.  
  1346.             /* if library call, delete all insn except last, which
  1347.                is deleted below */
  1348.             if (temp = find_reg_note (m1->insn, REG_RETVAL, 0))
  1349.               {
  1350.             for (temp = XEXP (temp, 0); temp != m1->insn;
  1351.                  temp = NEXT_INSN (temp))
  1352.                 delete_insn (temp);
  1353.               }
  1354.             delete_insn (m1->insn);
  1355.  
  1356.             /* Any other movable that loads the same register
  1357.                MUST be moved.  */
  1358.             already_moved[m1->regno] = 1;
  1359.  
  1360.             /* The reg merged here is now invariant,
  1361.                if the reg it matches is invariant.  */
  1362.             if (! m->partial)
  1363.               n_times_set[m1->regno] = 0;
  1364.           }
  1365.         }
  1366.       else if (loop_dump_stream)
  1367.         fprintf (loop_dump_stream, "not desirable");
  1368.     }
  1369.       else if (loop_dump_stream && !m->match)
  1370.     fprintf (loop_dump_stream, "not safe");
  1371.  
  1372.       if (loop_dump_stream)
  1373.     fprintf (loop_dump_stream, "\n");
  1374.     }
  1375.  
  1376.   if (new_start == 0)
  1377.     new_start = loop_start;
  1378.  
  1379.   /* Go through all the instructions in the loop, making
  1380.      all the register substitutions scheduled in REG_MAP.  */
  1381.   for (p = new_start; p != end; p = NEXT_INSN (p))
  1382.     if (GET_CODE (p) == INSN || GET_CODE (p) == JUMP_INSN
  1383.     || GET_CODE (p) == CALL_INSN)
  1384.       replace_regs (PATTERN (p), reg_map, nregs);
  1385. }
  1386.  
  1387. /* Optionally change a loop which enters just before the endtest
  1388.    to one which falls straight in
  1389.    after skipping around the entire loop if the endtest would drop out.
  1390.    Returns 1 if the change was made, 0 if the loop was not really suitable.  */
  1391.  
  1392. int
  1393. loop_skip_over (start, end, loop_entry_jump)
  1394.      rtx start;
  1395.      rtx end;
  1396.      rtx loop_entry_jump;
  1397. {
  1398.   rtx entry_insn;
  1399.   rtx endtest;
  1400.   rtx endtestjump;
  1401.   register rtx p = JUMP_LABEL (loop_entry_jump);
  1402.  
  1403.   while (GET_CODE (p) != INSN && GET_CODE (p) != JUMP_INSN
  1404.      && GET_CODE (p) != CALL_INSN)
  1405.     p = NEXT_INSN (p);
  1406.   entry_insn = p;
  1407.  
  1408.   /* Skip any ordinary arithmetic insns to find the compare.  */
  1409.   for (; p != 0; p = NEXT_INSN (p))
  1410.     if (GET_CODE (p) != NOTE)
  1411.       if (GET_CODE (p) != INSN || sets_cc0_p (PATTERN (p)))
  1412.     break;
  1413.   if (p == 0 || GET_CODE (p) != INSN)
  1414.     return 0;
  1415.   endtest = p;
  1416.   endtestjump = next_real_insn (p);
  1417.  
  1418.   /* Check that (1) we have reached a compare insn and (2)
  1419.      the insn (presumably a jump) following that compare
  1420.      is the last in the loop and jumps back to the loop beginning.  */
  1421.  
  1422.   if (sets_cc0_p (PATTERN (endtest)) > 0
  1423.       && endtestjump == prev_real_insn (end)
  1424.       && prev_real_insn (JUMP_LABEL (endtestjump)) == loop_entry_jump)
  1425.     {
  1426.       rtx newlab;
  1427.       /* This is the jump that we insert.  */
  1428.       rtx new_jump;
  1429.  
  1430.       /* Duplicate the ordinary arith insns before the compare.  */
  1431.       for (p = entry_insn; p != endtest; p = NEXT_INSN (p))
  1432.     if (GET_CODE (p) == INSN)
  1433.       {
  1434.         rtx new = emit_insn_before (copy_rtx (PATTERN (p)), start);
  1435.         if (REG_NOTES (p))
  1436.           REG_NOTES (new) = copy_rtx (REG_NOTES (p));
  1437.       }
  1438.     
  1439.       /* Ok, duplicate that test before start of loop.  */
  1440.       emit_insn_before (copy_rtx (PATTERN (endtest)), start);
  1441.       /* Make a new entry-jump (before the original one)
  1442.      whose condition is opposite to the loop-around endtest
  1443.      and which jumps around the loop (to just after the ending NOTE).  */
  1444.       newlab = gen_label_rtx ();
  1445.       emit_label_after (newlab, end);
  1446.       emit_jump_insn_before (copy_rtx (PATTERN (endtestjump)), start);
  1447.       new_jump = PREV_INSN (start);
  1448.       JUMP_LABEL (new_jump) = JUMP_LABEL (endtestjump);
  1449.       LABEL_NUSES (JUMP_LABEL (endtestjump))++;
  1450.       invert_jump (new_jump, newlab);
  1451.       /* Delete the original entry-jump.  */
  1452.       delete_insn (loop_entry_jump);
  1453.  
  1454.       return 1;
  1455.     }
  1456.  
  1457.   return 0;
  1458. }
  1459.  
  1460. /* Throughout the rtx X, replace many registers according to REG_MAP.
  1461.    Return the replacement for X (which may be X with altered contents).
  1462.    REG_MAP[R] is the replacement for register R, or 0 for don't replace.
  1463.    NREGS is the length of REG_MAP; regs >= NREGS are not mapped.  */
  1464.  
  1465. static rtx
  1466. replace_regs (x, reg_map, nregs)
  1467.      rtx x;
  1468.      rtx *reg_map;
  1469.      int nregs;
  1470. {
  1471.   register enum rtx_code code;
  1472.   register int i;
  1473.   register char *fmt;
  1474.  
  1475.   if (x == 0)
  1476.     return x;
  1477.  
  1478.   code = GET_CODE (x);
  1479.   switch (code)
  1480.     {
  1481.     case PC:
  1482.     case CC0:
  1483.     case CONST_INT:
  1484.     case CONST_DOUBLE:
  1485.     case CONST:
  1486.     case SYMBOL_REF:
  1487.     case LABEL_REF:
  1488.       return x;
  1489.  
  1490.     case REG:
  1491.       /* Verify that the register has an entry before trying to access it.  */
  1492.       if (REGNO (x) < nregs && reg_map[REGNO (x)] != 0)
  1493.     return reg_map[REGNO (x)];
  1494.       return x;
  1495.     }
  1496.  
  1497.   fmt = GET_RTX_FORMAT (code);
  1498.   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
  1499.     {
  1500.       if (fmt[i] == 'e')
  1501.     XEXP (x, i) = replace_regs (XEXP (x, i), reg_map, nregs);
  1502.       if (fmt[i] == 'E')
  1503.     {
  1504.       register int j;
  1505.       for (j = 0; j < XVECLEN (x, i); j++)
  1506.         XVECEXP (x, i, j) = replace_regs (XVECEXP (x, i, j), reg_map, nregs);
  1507.     }
  1508.     }
  1509.   return x;
  1510. }
  1511.  
  1512. /* Scan X and replace the address of any MEM in it with ADDR.
  1513.    REG is the address that MEM should have before the replacement.  */
  1514.  
  1515. static void
  1516. replace_call_address (x, reg, addr)
  1517.      rtx x, reg, addr;
  1518. {
  1519.   register enum rtx_code code;
  1520.   register int i;
  1521.   register char *fmt;
  1522.  
  1523.   if (x == 0)
  1524.     return;
  1525.   code = GET_CODE (x);
  1526.   switch (code)
  1527.     {
  1528.     case PC:
  1529.     case CC0:
  1530.     case CONST_INT:
  1531.     case CONST_DOUBLE:
  1532.     case CONST:
  1533.     case SYMBOL_REF:
  1534.     case LABEL_REF:
  1535.     case REG:
  1536.       return;
  1537.  
  1538.     case SET:
  1539.       /* Short cut for very common case.  */
  1540.       replace_call_address (XEXP (x, 1), reg, addr);
  1541.       return;
  1542.  
  1543.     case CALL:
  1544.       /* Short cut for very common case.  */
  1545.       replace_call_address (XEXP (x, 0), reg, addr);
  1546.       return;
  1547.  
  1548.     case MEM:
  1549.       /* If this MEM uses a reg other than the one we expected,
  1550.      something is wrong.  */
  1551.       if (XEXP (x, 0) != reg)
  1552.     abort ();
  1553.       XEXP (x, 0) = addr;
  1554.       return;
  1555.     }
  1556.  
  1557.   fmt = GET_RTX_FORMAT (code);
  1558.   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
  1559.     {
  1560.       if (fmt[i] == 'e')
  1561.     replace_call_address (XEXP (x, i), reg, addr);
  1562.       if (fmt[i] == 'E')
  1563.     {
  1564.       register int j;
  1565.       for (j = 0; j < XVECLEN (x, i); j++)
  1566.         replace_call_address (XVECEXP (x, i, j), reg, addr);
  1567.     }
  1568.     }
  1569. }
  1570.  
  1571. /* Return the number of memory refs to addresses that vary
  1572.    in the rtx X.  */
  1573.  
  1574. static int
  1575. count_nonfixed_reads (x)
  1576.      rtx x;
  1577. {
  1578.   register enum rtx_code code;
  1579.   register int i;
  1580.   register char *fmt;
  1581.   int value;
  1582.  
  1583.   if (x == 0)
  1584.     return 0;
  1585.  
  1586.   code = GET_CODE (x);
  1587.   switch (code)
  1588.     {
  1589.     case PC:
  1590.     case CC0:
  1591.     case CONST_INT:
  1592.     case CONST_DOUBLE:
  1593.     case CONST:
  1594.     case SYMBOL_REF:
  1595.     case LABEL_REF:
  1596.     case REG:
  1597.       return 0;
  1598.  
  1599.     case MEM:
  1600.       return rtx_varies_p (XEXP (x, 0)) + count_nonfixed_reads (XEXP (x, 0));
  1601.     }
  1602.  
  1603.   value = 0;
  1604.   fmt = GET_RTX_FORMAT (code);
  1605.   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
  1606.     {
  1607.       if (fmt[i] == 'e')
  1608.     value += count_nonfixed_reads (XEXP (x, i));
  1609.       if (fmt[i] == 'E')
  1610.     {
  1611.       register int j;
  1612.       for (j = 0; j < XVECLEN (x, i); j++)
  1613.         value += count_nonfixed_reads (XVECEXP (x, i, j));
  1614.     }
  1615.     }
  1616.   return value;
  1617. }
  1618.  
  1619.  
  1620. #if 0
  1621. /* P is an instruction that sets a register to the result of a ZERO_EXTEND.
  1622.    Replace it with an instruction to load just the low bytes
  1623.    if the machine supports such an instruction,
  1624.    and insert above LOOP_START an instruction to clear the register.  */
  1625.  
  1626. static void
  1627. constant_high_bytes (p, loop_start)
  1628.      rtx p, loop_start;
  1629. {
  1630.   register rtx new;
  1631.   register int insn_code_number;
  1632.  
  1633.   /* Try to change (SET (REG ...) (ZERO_EXTEND (..:B ...)))
  1634.      to (SET (STRICT_LOW_PART (SUBREG:B (REG...))) ...).  */
  1635.  
  1636.   new = gen_rtx (SET, VOIDmode,
  1637.          gen_rtx (STRICT_LOW_PART, VOIDmode,
  1638.               gen_rtx (SUBREG, GET_MODE (XEXP (SET_SRC (PATTERN (p)), 0)),
  1639.                    SET_DEST (PATTERN (p)),
  1640.                    0)),
  1641.          XEXP (SET_SRC (PATTERN (p)), 0));
  1642.   insn_code_number = recog (new, p);
  1643.  
  1644.   if (insn_code_number)
  1645.     {
  1646.       register int i;
  1647.  
  1648.       /* Clear destination register before the loop.  */
  1649.       emit_insn_before (gen_rtx (SET, VOIDmode,
  1650.                  SET_DEST (PATTERN (p)),
  1651.                  const0_rtx),
  1652.             loop_start);
  1653.  
  1654.       /* Inside the loop, just load the low part.  */
  1655.       PATTERN (p) = new;
  1656.     }
  1657. }
  1658. #endif
  1659.  
  1660. /* Verify that the ostensible loop starting at START
  1661.    really is a loop: nothing jumps into it from outside.
  1662.    Return the marker for the end of the loop, or zero if not a real loop.
  1663.  
  1664.    Also set the variables `unknown_*_altered' and `loop_has_call',
  1665.    and fill in the array `loop_store_addrs'.  */
  1666.  
  1667. static rtx
  1668. verify_loop (f, start)
  1669.      rtx f, start;
  1670. {
  1671.   register int level = 1;
  1672.   register rtx insn, end;
  1673.  
  1674.   /* First find the LOOP_END that matches.
  1675.      Also check each insn for storing in memory and record where.  */
  1676.  
  1677.   unknown_address_altered = 0;
  1678.   unknown_aggregate_altered = 0;
  1679.   fixed_aggregate_altered = 0;
  1680.   loop_has_call = 0;
  1681.   loop_store_addrs_idx = 0;
  1682.  
  1683.   num_mem_sets = 0;
  1684.   loops_enclosed = 1;
  1685.   loop_continue = 0;
  1686.  
  1687.   for (insn = NEXT_INSN (start); level > 0; insn = NEXT_INSN (insn))
  1688.     {
  1689.       if (insn == 0)
  1690.     /* Parse errors can cause a loop-beg with no loop-end.  */
  1691.     return 0;
  1692.       if (GET_CODE (insn) == NOTE)
  1693.     {
  1694.       if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
  1695.         {
  1696.           ++level;
  1697.           /* Count number of loops contained in this one.  */
  1698.           loops_enclosed++;
  1699.         }
  1700.       else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
  1701.         {
  1702.           --level;
  1703.           if (level == 0)
  1704.         {
  1705.           end = insn;
  1706.           break;
  1707.         }
  1708.         }
  1709.       else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_CONT)
  1710.         {
  1711.           if (level == 1)
  1712.         loop_continue = insn;
  1713.         }
  1714.  
  1715.       /* Don't optimize loops containing setjmps.
  1716.          On some machines, longjmp does not restore the reg
  1717.          values as of the time of the setjmp.  */
  1718.       else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)
  1719.         return 0;
  1720.     }
  1721.       else if (GET_CODE (insn) == CALL_INSN)
  1722.     {
  1723.       unknown_address_altered = 1;
  1724.       loop_has_call = 1;
  1725.     }
  1726. /* ???
  1727.       else if (! unknown_address_altered) */
  1728.       else
  1729.     {
  1730.       if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN)
  1731.         note_stores (PATTERN (insn), note_addr_stored);
  1732.     }
  1733.     }
  1734.  
  1735.   /* Now scan all jumps in the function and see if any of them can
  1736.      reach a label within the range of the loop.  */
  1737.  
  1738.   for (insn = f; insn; insn = NEXT_INSN (insn))
  1739.     if (GET_CODE (insn) == JUMP_INSN
  1740.     /* Don't get fooled by jumps inserted by loop-optimize.
  1741.        They don't have valid LUIDs, and they never jump into loops.  */
  1742.     && INSN_UID (insn) < max_uid
  1743.     && (INSN_LUID (insn) < INSN_LUID (start)
  1744.         || INSN_LUID (insn) > INSN_LUID (end))
  1745.     /* We have a jump that is outside the loop.
  1746.        Does it jump into the loop?  */
  1747.     && can_jump_into_range_p (PATTERN (insn),
  1748.                   INSN_LUID (start), INSN_LUID (end)))
  1749.       return 0;
  1750.  
  1751. #if 0      
  1752.   /* Now scan all labels between them and check for any jumps from outside.
  1753.      This uses the ref-chains set up by find_basic_blocks.
  1754.      This code is not used because it's more convenient for other reasons
  1755.      to do the loop optimization before find_basic_blocks.  */
  1756.  
  1757.   for (insn = start; insn != end; insn = NEXT_INSN (insn))
  1758.     if (GET_CODE (insn) == CODE_LABEL)
  1759.       {
  1760.     register rtx y;
  1761.     for (y = LABEL_REFS (insn); y != insn; y = LABEL_NEXTREF (y))
  1762.       if (INSN_LUID (CONTAINING_INSN (y)) < INSN_LUID (start)
  1763.           || INSN_LUID (CONTAINING_INSN (y)) > INSN_LUID (end))
  1764.         return 0;
  1765.       }
  1766. #endif
  1767.  
  1768.   return end;
  1769. }
  1770.  
  1771. /* Return 1 if somewhere in X is a LABEL_REF to a label
  1772.    located between BEG and END.  */
  1773.  
  1774. static int
  1775. can_jump_into_range_p (x, beg, end)
  1776.      rtx x;
  1777.      int beg, end;
  1778. {
  1779.   register enum rtx_code code = GET_CODE (x);
  1780.   register int i;
  1781.   register char *fmt;
  1782.  
  1783.   if (code == LABEL_REF)
  1784.     {
  1785.       register int luid = INSN_LUID (XEXP (x, 0));
  1786.       return luid > beg && luid < end;
  1787.     }
  1788.  
  1789.   fmt = GET_RTX_FORMAT (code);
  1790.   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
  1791.     {
  1792.       if (fmt[i] == 'e')
  1793.     {
  1794.       if (can_jump_into_range_p (XEXP (x, i), beg, end))
  1795.         return 1;
  1796.     }
  1797.       else if (fmt[i] == 'E')
  1798.     {
  1799.       register int j;
  1800.       for (j = 0; j < XVECLEN (x, i); j++)
  1801.         if (can_jump_into_range_p (XVECEXP (x, i, j), beg, end))
  1802.           return 1;
  1803.     }
  1804.     }
  1805.  
  1806.   return 0;
  1807. }
  1808.  
  1809. /* Return nonzero if there is a label in the range from
  1810.    insn INSN to the insn whose luid is END.  */
  1811.  
  1812. static int
  1813. labels_in_range_p (insn, end)
  1814.      rtx insn;
  1815.      int end;
  1816. {
  1817.   while (insn && INSN_LUID (insn) <= end)
  1818.     {
  1819.       if (GET_CODE (insn) == CODE_LABEL)
  1820.     return 0;
  1821.       insn = NEXT_INSN (insn);
  1822.     }
  1823.  
  1824.   return 0;
  1825. }
  1826.  
  1827. /* Record that a memory reference X is being set.  */
  1828.  
  1829. static void
  1830. note_addr_stored (x)
  1831.      rtx x;
  1832. {
  1833.   if (x == 0 || GET_CODE (x) != MEM)
  1834.     return;
  1835.  
  1836.   /* Count number of memory writes.
  1837.      This affects heuristics in strength_reduce.  */
  1838.   num_mem_sets++;
  1839.   if (unknown_address_altered)
  1840.     return;
  1841.  
  1842.   if (GET_MODE (x) == BLKmode)
  1843.     unknown_address_altered = 1;
  1844.   else if (rtx_addr_varies_p (x))
  1845.     {
  1846.       if (GET_CODE (XEXP (x, 0)) == PLUS)
  1847.     unknown_aggregate_altered = 1;
  1848.       else
  1849.     unknown_address_altered = 1;
  1850.     }
  1851.   else
  1852.     {
  1853.       register int i;
  1854.       register rtx addr = XEXP (x, 0);
  1855.  
  1856.       if (MEM_IN_STRUCT_P (x))
  1857.     fixed_aggregate_altered = 1;
  1858.       for (i = 0; i < loop_store_addrs_idx; i++)
  1859.     if (rtx_equal_p (loop_store_addrs[i], addr))
  1860.       {
  1861.         if (loop_store_widths[i] < GET_MODE_SIZE (GET_MODE (x)))
  1862.           loop_store_widths[i] = GET_MODE_SIZE (GET_MODE (x));
  1863.         break;
  1864.       }
  1865.       if (i == NUM_STORES)
  1866.     unknown_address_altered = 1;
  1867.       else if (i == loop_store_addrs_idx)
  1868.     {
  1869.       loop_store_widths[i] = GET_MODE_SIZE (GET_MODE (x));
  1870.       loop_store_addrs[loop_store_addrs_idx++] = addr;
  1871.     }
  1872.     }
  1873. }
  1874.  
  1875. /* Return nonzero if the rtx X is invariant over the current loop.
  1876.  
  1877.    The value is 2 if we refer to something only conditionally invariant.
  1878.  
  1879.    If `unknown_address_altered' is nonzero, no memory ref is invariant.
  1880.    Otherwise if `unknown_aggregate_altered' is nonzero,
  1881.    a memory ref is invariant if it is not part of an aggregate
  1882.    and its address is fixed and not in `loop_store_addrs'.
  1883.    Otherwise if `fixed_aggregate_altered' is nonzero,
  1884.    a memory ref is invariant
  1885.    if its address is fixed and not in `loop_store_addrs'.
  1886.    Otherwise, a memory ref is invariant if its address is fixed and not in
  1887.    `loop_store_addrs' or if it is not an aggregate.  */
  1888.  
  1889. static int
  1890. invariant_p (x)
  1891.      register rtx x;
  1892. {
  1893.   register int i;
  1894.   register enum rtx_code code;
  1895.   register char *fmt;
  1896.   int conditional = 0;
  1897.  
  1898.   if (x == 0)
  1899.     return 1;
  1900.   code = GET_CODE (x);
  1901.   switch (code)
  1902.     {
  1903.     case CONST_INT:
  1904.     case CONST_DOUBLE:
  1905.     case SYMBOL_REF:
  1906.     case LABEL_REF:
  1907.     case CONST:
  1908.       return 1;
  1909.  
  1910.     case PC:
  1911.     case CC0:
  1912.       return 0;
  1913.  
  1914.     case REG:
  1915.       /* We used to check RTX_UNCHANGING_P (x) here, but that is invalid
  1916.      since the reg might be set by initialization within the loop.  */
  1917.       if (x == frame_pointer_rtx || x == arg_pointer_rtx)
  1918.     return 1;
  1919.       if (n_times_set[REGNO (x)] == -1)
  1920.     return 2;
  1921.       return n_times_set[REGNO (x)] == 0;
  1922.  
  1923.     case MEM:
  1924.       /* Constants in the constant pool are invariant.
  1925.      ?? Really we should detect any constant address in the
  1926.      text section.  */
  1927.       if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
  1928.       && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
  1929.     return 1;
  1930.       /* A store in a varying-address scalar (or a subroutine call)
  1931.      could clobber anything in memory.  */
  1932.       if (unknown_address_altered)
  1933.     return 0;
  1934.       /* Don't mess with volatile memory references.  */
  1935.       if (MEM_VOLATILE_P (x))
  1936.     return 0;
  1937. #if 0
  1938.       /* If it's declared read-only, it is invariant
  1939.      if its address is invariant.  */
  1940.       if (RTX_UNCHANGING_P (x))
  1941.     return invariant_p (XEXP (x, 0));
  1942. #endif
  1943.       /* A store in a varying-address aggregate component
  1944.      could clobber anything except a scalar with a fixed address.  */
  1945.       if (unknown_aggregate_altered
  1946.       && ((MEM_IN_STRUCT_P (x) || GET_CODE (XEXP (x, 0)) == PLUS)
  1947.           || rtx_addr_varies_p (x)))
  1948.     return 0;
  1949.       /* A store in a fixed-address aggregate component
  1950.      could clobber anything whose address is not fixed,
  1951.      even an aggregate component.  */
  1952.       if (fixed_aggregate_altered
  1953.       && rtx_addr_varies_p (x))
  1954.     return 0;
  1955.       /* Any store could clobber a varying-address scalar.  */
  1956.       if (loop_store_addrs_idx
  1957.       && !(MEM_IN_STRUCT_P (x) || GET_CODE (XEXP (x, 0)) == PLUS)
  1958.       && rtx_addr_varies_p (x))
  1959.     return 0;
  1960.       /* A store in a fixed address clobbers overlapping references.  */
  1961.       for (i = loop_store_addrs_idx - 1; i >= 0; i--)
  1962.     if (addr_overlap_p (x, loop_store_addrs[i], loop_store_widths[i]))
  1963.       return 0;
  1964.       /* It's not invalidated by a store in memory
  1965.      but we must still verify the address is invariant.  */
  1966.       break;
  1967.  
  1968.     case ASM_OPERANDS:
  1969.       /* Don't mess with insns declared volatile.  */
  1970.       if (MEM_VOLATILE_P (x))
  1971.     return 0;
  1972.     }
  1973.  
  1974.   fmt = GET_RTX_FORMAT (code);
  1975.   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
  1976.     {
  1977.       if (fmt[i] == 'e')
  1978.     {
  1979.       int tem = invariant_p (XEXP (x, i));
  1980.       if (tem == 0)
  1981.         return 0;
  1982.       if (tem == 2)
  1983.         conditional = 1;
  1984.     }
  1985.       else if (fmt[i] == 'E')
  1986.     {
  1987.       register int j;
  1988.       for (j = 0; j < XVECLEN (x, i); j++)
  1989.         {
  1990.           int tem = invariant_p (XVECEXP (x, i, j));
  1991.           if (tem == 0)
  1992.         return 0;
  1993.           if (tem == 2)
  1994.         conditional = 1;
  1995.         }
  1996.  
  1997.     }
  1998.     }
  1999.  
  2000.   return 1 + conditional;
  2001. }
  2002.  
  2003. /* Return 1 if OTHER (a mem ref) overlaps the area of memory
  2004.    which is SIZE bytes starting at BASE.  */
  2005.  
  2006. int
  2007. addr_overlap_p (other, base, size)
  2008.      rtx other;
  2009.      rtx base;
  2010.      int size;
  2011. {
  2012.   int start = 0, end;
  2013.  
  2014.   if (GET_CODE (base) == CONST)
  2015.     base = XEXP (base, 0);
  2016.   if (GET_CODE (base) == PLUS
  2017.       && GET_CODE (XEXP (base, 1)) == CONST_INT)
  2018.     {
  2019.       start = INTVAL (XEXP (base, 1));
  2020.       base = XEXP (base, 0);
  2021.     }
  2022.  
  2023.   end = start + size;
  2024.   return refers_to_mem_p (other, base, start, end);
  2025. }
  2026.  
  2027. /* Return nonzero if all the insns in the loop that set REG
  2028.    are INSN and the immediately following insns,
  2029.    and if each of those insns sets REG in an invariant way
  2030.    (not counting uses of REG in them).
  2031.  
  2032.    The value is 2 if some of these insns are only conditionally invariant.
  2033.  
  2034.    We assume that INSN itself is the first set of REG
  2035.    and that its source is invariant.  */
  2036.  
  2037. static int
  2038. consec_sets_invariant_p (reg, n_sets, insn)
  2039.      int n_sets;
  2040.      rtx reg, insn;
  2041. {
  2042.   register rtx p = insn;
  2043.   register int regno = REGNO (reg);
  2044.   rtx temp;
  2045.   /* Number of sets we have to insist on finding after INSN.  */
  2046.   int count = n_sets - 1;
  2047.   int old = n_times_set[regno];
  2048.   int value = 0;
  2049.   int this;
  2050.  
  2051.   /* If N_SETS hit the limit, we can't rely on its value.  */
  2052.   if (n_sets == 127)
  2053.     return 0;
  2054.  
  2055.   n_times_set[regno] = 0;
  2056.  
  2057.   while (count > 0)
  2058.     {
  2059.       register enum rtx_code code;
  2060.       p = NEXT_INSN (p);
  2061.       code = GET_CODE (p);
  2062.  
  2063.       /* If library call, skip to end of of it.  */
  2064.       if (code == INSN && (temp = find_reg_note (p, REG_LIBCALL, 0)))
  2065.     p = XEXP (temp, 0);
  2066.  
  2067.       this = 0;
  2068.       if (code == INSN && GET_CODE (PATTERN (p)) == SET
  2069.       && GET_CODE (SET_DEST (PATTERN (p))) == REG
  2070.       && REGNO (SET_DEST (PATTERN (p))) == regno)
  2071.     {
  2072.       this = invariant_p (SET_SRC (PATTERN (p)));
  2073.       if (this != 0)
  2074.         value |= this;
  2075.       else if (temp = find_reg_note (p, REG_EQUAL, 0))
  2076.         {
  2077.           this = invariant_p (XEXP (temp, 0));
  2078.           if (this != 0)
  2079.         value |= this;
  2080.         }
  2081.     }
  2082.       if (this != 0)
  2083.     count--;
  2084.       else if (code != NOTE)
  2085.     {
  2086.       n_times_set[regno] = old;
  2087.       return 0;
  2088.     }
  2089.     }
  2090.  
  2091.   n_times_set[regno] = old;
  2092.   /* If invariant_p ever returned 2, we return 2.  */
  2093.   return 1 + (value & 2);
  2094. }
  2095.  
  2096. #if 0
  2097. /* I don't think this condition is sufficient to allow INSN
  2098.    to be moved, so we no longer test it.  */
  2099.  
  2100. /* Return 1 if all insns in the basic block of INSN and following INSN
  2101.    that set REG are invariant according to TABLE.  */
  2102.  
  2103. static int
  2104. all_sets_invariant_p (reg, insn, table)
  2105.      rtx reg, insn;
  2106.      short *table;
  2107. {
  2108.   register rtx p = insn;
  2109.   register int regno = REGNO (reg);
  2110.  
  2111.   while (1)
  2112.     {
  2113.       register enum rtx_code code;
  2114.       p = NEXT_INSN (p);
  2115.       code = GET_CODE (p);
  2116.       if (code == CODE_LABEL || code == JUMP_INSN)
  2117.     return 1;
  2118.       if (code == INSN && GET_CODE (PATTERN (p)) == SET
  2119.       && GET_CODE (SET_DEST (PATTERN (p))) == REG
  2120.       && REGNO (SET_DEST (PATTERN (p))) == regno)
  2121.     {
  2122.       if (!invariant_p (SET_SRC (PATTERN (p)), table))
  2123.         return 0;
  2124.     }
  2125.     }
  2126. }
  2127. #endif /* 0 */
  2128.  
  2129. /* Increment N_TIMES_SET at the index of each register
  2130.    that is modified by an insn between FROM and TO.
  2131.    If the value of an element of N_TIMES_SET becomes 127 or more,
  2132.    stop incrementing it, to avoid overflow.
  2133.  
  2134.    Store in *COUNT_PTR the number of actual instruction
  2135.    in the loop.  We use this to decide what is worth moving out.  */
  2136.  
  2137. /* last_set[n] is nonzero iff reg n has been set in the current basic block.
  2138.    In that case, it is the insn that last set reg n.  */
  2139.  
  2140. static void
  2141. count_loop_regs_set (from, to, may_not_move, count_ptr, nregs)
  2142.      register rtx from, to;
  2143.      char *may_not_move;
  2144.      int *count_ptr;
  2145.      int nregs;
  2146. {
  2147.   register rtx *last_set = (rtx *) alloca (nregs * sizeof (rtx));
  2148.   register rtx insn;
  2149.   register int count = 0;
  2150.   register rtx dest;
  2151.  
  2152.   bzero (last_set, nregs * sizeof (rtx));
  2153.   for (insn = from; insn != to; insn = NEXT_INSN (insn))
  2154.     {
  2155.       if (GET_CODE (insn) == CALL_INSN)
  2156.     {
  2157.       /* If a register is used as a subroutine address,
  2158.          don't allow this register's setting to be moved out of the loop.
  2159.          This condition is not at all logically correct
  2160.          but it averts a very common lossage pattern
  2161.          and creates lossage much less often.  */
  2162.       if (GET_CODE (PATTERN (insn)) == CALL
  2163.           && GET_CODE (XEXP (PATTERN (insn), 0)) == MEM
  2164.           && GET_CODE (XEXP (XEXP (PATTERN (insn), 0), 0)) == REG)
  2165.         {
  2166.           register int regno
  2167.         = REGNO (XEXP (XEXP (PATTERN (insn), 0), 0));
  2168.           may_not_move[regno] = 1;
  2169.         }
  2170.       else if (GET_CODE (PATTERN (insn)) == SET
  2171.           && GET_CODE (SET_SRC (PATTERN (insn))) == CALL
  2172.           && GET_CODE (XEXP (SET_SRC (PATTERN (insn)), 0)) == MEM
  2173.           && GET_CODE (XEXP (XEXP (SET_SRC (PATTERN (insn)), 0), 0)) == REG)
  2174.         {
  2175.           register int regno
  2176.         = REGNO (XEXP (XEXP (SET_SRC (PATTERN (insn)), 0), 0));
  2177.           may_not_move[regno] = 1;
  2178.           /* The call insn itself sets a reg, which cannot be moved.  */
  2179.           may_not_move[REGNO (SET_DEST (PATTERN (insn)))] = 1;
  2180.           if (n_times_set[REGNO (SET_DEST (PATTERN (insn)))] < 127)
  2181.         n_times_set[REGNO (SET_DEST (PATTERN (insn)))]++;
  2182.         }
  2183.     }
  2184.       if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN) 
  2185.     {
  2186.       ++count;
  2187.       if (GET_CODE (PATTERN (insn)) == CLOBBER
  2188.           && GET_CODE (XEXP (PATTERN (insn), 0)) == REG)
  2189.         /* Don't move a reg that has an explicit clobber.
  2190.            We might do so sometimes, but it's not worth the pain.  */
  2191.         may_not_move[REGNO (XEXP (PATTERN (insn), 0))] = 1;
  2192.       else if (GET_CODE (PATTERN (insn)) == SET)
  2193.         {
  2194.           dest = SET_DEST (PATTERN (insn));
  2195.           while (GET_CODE (dest) == SUBREG
  2196.              || GET_CODE (dest) == ZERO_EXTRACT
  2197.              || GET_CODE (dest) == SIGN_EXTRACT
  2198.              || GET_CODE (dest) == STRICT_LOW_PART)
  2199.         dest = XEXP (dest, 0);
  2200.           if (GET_CODE (dest) == REG)
  2201.         {
  2202.           register int regno = REGNO (dest);
  2203.           /* If this is the first setting of this reg
  2204.              in current basic block, and it was set before,
  2205.              it must be set in two basic blocks, so it cannot
  2206.              be moved out of the loop.  */
  2207.           if (n_times_set[regno] > 0 && last_set[regno] == 0)
  2208.             may_not_move[regno] = 1;
  2209.           /* If this is not first setting in current basic block,
  2210.              see if reg was used in between previous one and this.
  2211.              If so, neither one can be moved.  */
  2212.           if (last_set[regno] != 0
  2213.               && reg_used_between_p (dest, last_set[regno], insn))
  2214.             may_not_move[regno] = 1;
  2215.           if (n_times_set[regno] < 127)
  2216.             ++n_times_set[regno];
  2217.           last_set[regno] = insn;
  2218.         }
  2219.         }
  2220.       else if (GET_CODE (PATTERN (insn)) == PARALLEL)
  2221.         {
  2222.           register int i;
  2223.           for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
  2224.         {
  2225.           register rtx x = XVECEXP (PATTERN (insn), 0, i);
  2226.           if (GET_CODE (x) == CLOBBER && GET_CODE (XEXP (x, 0)) == REG)
  2227.             /* Don't move a reg that has an explicit clobber.
  2228.                It's not worth the pain to try to do it correctly.  */
  2229.             may_not_move[REGNO (XEXP (x, 0))] = 1;
  2230.           if (GET_CODE (x) == SET)
  2231.             {
  2232.               dest = SET_DEST (x);
  2233.               while (GET_CODE (dest) == SUBREG
  2234.                  || GET_CODE (dest) == ZERO_EXTRACT
  2235.                  || GET_CODE (dest) == SIGN_EXTRACT
  2236.                  || GET_CODE (dest) == STRICT_LOW_PART)
  2237.             dest = XEXP (dest, 0);
  2238.               if (GET_CODE (dest) == REG)
  2239.             {
  2240.               register int regno = REGNO (dest);
  2241.               if (n_times_set[regno] < 127)
  2242.                 ++n_times_set[regno];
  2243.               may_not_move[regno] = 1;
  2244.               last_set[regno] = insn;
  2245.             }
  2246.             }
  2247.         }
  2248.         }
  2249.     }
  2250.       if (GET_CODE (insn) == CODE_LABEL || GET_CODE (insn) == JUMP_INSN)
  2251.     bzero (last_set, nregs * sizeof (rtx));
  2252.     }
  2253.   *count_ptr = count;
  2254. }
  2255.  
  2256. /* Given a loop that is bounded by LOOP_START and LOOP_END
  2257.    and that is entered at SCAN_START,
  2258.    return 1 if the register set by insn INSN is used by
  2259.    any insn that precedes INSN in cyclic order starting
  2260.    from the loop entry point.  */
  2261.  
  2262. static int
  2263. loop_reg_used_before_p (insn, loop_start, scan_start, loop_end)
  2264.      rtx insn, loop_start, scan_start, loop_end;
  2265. {
  2266.   rtx reg = SET_DEST (PATTERN (insn));
  2267.   if (INSN_LUID (scan_start) > INSN_LUID (insn))
  2268.     return (reg_used_between_p (reg, scan_start, loop_end)
  2269.         || reg_used_between_p (reg, loop_start, insn));
  2270.   else
  2271.     return reg_used_between_p (reg, scan_start, insn);
  2272. }
  2273.  
  2274. /* A "basic induction variable" or biv is a pseudo reg that is set
  2275.    (within this loop) only by incrementing or decrementing it.  */
  2276. /* A "general induction variable" or giv is a pseudo reg whose
  2277.    value is a linear function of a biv.  */
  2278.  
  2279. /* Bivs are recognized by `basic_induction_var';
  2280.    Givs by `general_induct_var'.  */
  2281.  
  2282. /* An enum for the two different types of givs, those that are used
  2283.    as memory addresses and those that are calculated into registers.  */
  2284. enum g_types { DEST_ADDR, DEST_REG };
  2285.  
  2286. /* A `struct induction' is created for every instruction that sets
  2287.    an induction variable (either a biv or a giv).  */
  2288.  
  2289. struct induction
  2290. {
  2291.   rtx insn;               /* The insn that sets a biv or giv */
  2292.   rtx new_reg;               /* New register, containing strength reduced
  2293.                   version of this giv.  */
  2294.   int src_regno;           /* Biv from which this giv is computed.
  2295.                   (If this is a biv, then this is the biv.)  */
  2296.   enum g_types giv_type;       /* Indicate whether DEST_ADDR or DEST_REG giv */
  2297.   int dest_regno;           /* Destination register for insn: this is the
  2298.                   register which was the biv or giv.
  2299.                   For a biv, this equals src_reg.
  2300.                   For a DEST_ADDR type giv, this is 0.  */
  2301.   rtx *location;           /* Place in the insn where this giv occurs.
  2302.                   If GIV_TYPE is DEST_REG, this is 0.  */
  2303.   enum machine_mode mode;      /* The mode of this biv or giv */
  2304.   rtx mult_val;               /* Multiplicative factor for src_reg.  */
  2305.   rtx add_val;               /* Additive constant for that product.  */
  2306.   int benefit;               /* Gain from eliminating this insn.  */
  2307.   int consec;               /* The number of consecutive insn that set this
  2308.                   register; they are all eliminated if this
  2309.                   one is.  */
  2310.   char replaceable;           /* 1 if we can substitute the strength-reduced
  2311.                   variable for the original variable.
  2312.                   0 means they must be kept separate and the
  2313.                   new one must be copied into the old pseudo
  2314.                   reg each time the old one is set.  */
  2315.   char ignore;               /* 1 prohibits further processing of this giv */
  2316.   int lifetime;               /* Length of life of this giv */
  2317.   int times_used;           /* # times this giv is used. */
  2318.   struct induction *family;    /* Links together all induction variables that
  2319.                   have the same src register.  */
  2320.   struct induction *forces;    /* Points to an induction variable insn which
  2321.                   is used only once, to compute this giv,
  2322.                   and hence can be deleted if this insn is
  2323.                   strength reduced.  */
  2324.   struct induction *forces2;   /* Likewise.  */
  2325.   struct induction *same;      /* Links together all induction variables that
  2326.                   have the same tuple (src, mult, add).  */
  2327. };
  2328.  
  2329. /* A `struct iv_class' is created for each biv.  */
  2330.  
  2331. struct iv_class {
  2332.   int regno;                   /* Pseudo reg which is the biv.  */
  2333.   int biv_count;               /* Number of insns setting this reg.  */
  2334.   struct induction *biv;       /* List of all insns that set this reg.  */
  2335.   int giv_count;               /* Number of DEST_REG givs computed from this
  2336.                   biv.  The resulting count is only used in
  2337.                    check_dbra_loop.  */
  2338.   struct induction *giv;       /* List of all insns that compute a giv
  2339.                   from this reg.  */
  2340.   int total_benefit;           /* Sum of BENEFITs of all those givs */
  2341.   rtx initial_value;           /* Value of reg at loop start */
  2342.   struct iv_class *next;       /* Links all class structures together */
  2343.   rtx init_insn;           /* insn which intializes biv, 0 if none seen. */
  2344.   char eliminable;           /* 1 if plausible candidate for elimination.  */
  2345.   char nonneg;               /* 1 if we added a REG_NONNEG note for this.  */
  2346. };
  2347.  
  2348. /* Definitions used by the basic induction variable discovery code.  */
  2349. enum iv_mode { UNKNOWN_INDUCT, BASIC_INDUCT, NOT_BASIC_INDUCT,
  2350.          GENERAL_INDUCT };
  2351.  
  2352. /* Relative gain of eliminating various kinds of operations.  */
  2353. #define NO_BENEFIT    0
  2354. #define ADD_BENEFIT   1
  2355. #define SHIFT_BENEFIT 2
  2356. #define MULT_BENEFIT  4
  2357. #define LIBCALL_BENEFIT 15
  2358. /* Benefit penalty, if a giv is not replaceable, i.e. must emit an insn to
  2359.    copy the value of the strength reduced giv to its original register.  */
  2360. #define COPY_PENALTY  2
  2361.  
  2362. /* Indexed by register number, indicates whether or not register is an
  2363.    induction variable, and if so what type.  */
  2364.  
  2365. static enum iv_mode *induct_var;
  2366.  
  2367. /* Indexed by register number, contains pointer to `struct induction'
  2368.    if register is a general induction variable.  */
  2369.  
  2370. static struct induction **induct_struct;
  2371.  
  2372. /* Indexed by register number, contains pointer to `struct iv_class'
  2373.    if register is a basic induction variable.  */
  2374.  
  2375. static struct iv_class **class_struct;
  2376.  
  2377. /*********************************/
  2378.  
  2379. /* ??? Unfinished optimizations, wilson@ji.Berkeley.EDU */
  2380.  
  2381. /* strength reduce addresses found in sources (set () (mem ())*/
  2382.  
  2383. /* There is one more optimization you might be interested in doing: to
  2384.    allocate pseudo registers for frequently-accessed memory locations.
  2385.    If the same memory location is referenced each time around, it might
  2386.    be possible to copy it into a register before and out after.
  2387.    This is especially useful when the memory location is a variable which
  2388.    is in a stack slot because somewhere its address is taken.  If the
  2389.    loop doesn't contain a function call and the variable isn't volatile,
  2390.    it is safe to keep the value in a register for the duration of the
  2391.    loop. One tricky thing is that the copying of the value back from the
  2392.    register has to be done on all exits from the loop.  You need to check that
  2393.    all the exits from the loop go to the same place. */
  2394.  
  2395. /* WARNING: the interaction of biv elimination, and recognizing 'constant'
  2396.    bivs may cause problems */
  2397.  
  2398. /* add heuristic so that DEST_ADDR strength reduction does not cause
  2399.    performance problems */
  2400.  
  2401. /* don't eliminate things that can be combined with an addressing mode?
  2402.    find all giv that have same biv and mult_val (now must also have
  2403.    same add_val), then for each giv, check to see if its only use
  2404.    dies in a following memory address, generate a new memory address
  2405.    and check to see if valid, if valid then store modified mem addr,
  2406.    else if not valid addr mark giv as not done so that it will get its
  2407.    own iv */
  2408.  
  2409. /* consec_sets_giv does not calculate replaceable and forces correctly,
  2410.    forces should be a more general linked list instead of two entries */
  2411.  
  2412. /* try to optimize branches when it is known that a biv is always positive */
  2413.  
  2414. /* when replace biv in compare insn, should replace with closest giv so that
  2415.    an optimized branch can still be recognized by combiner, i.e. VAXen acb */
  2416.  
  2417. /* should merge final_value calculation in check_dbra_loop with the 
  2418.    new final_biv_value function */
  2419.  
  2420. /* many of the checks involving uid_luid could be simplified if regscan
  2421.    was rerun in loop_optimize() whenever a register was added or moved,
  2422.    also some of the optimizations could be a little less conservative */
  2423.  
  2424. /* Perform strength reduction and induction variable elimination.  */
  2425.  
  2426. /* Pseudo registers created during this function will be beyond the last
  2427.    valid index in several tables including n_times_set and regno_last_uid.
  2428.    This does not cause a problem here, because the added registers cannot be
  2429.    givs outside of their loop, and hence will never be reconsidered.
  2430.    But scan_loop must check regnos to make sure they are in bounds.  */
  2431.  
  2432. static void
  2433. strength_reduce (scan_start, end, loop_top, insn_count,
  2434.          loop_start, loop_end, nregs)
  2435.      rtx scan_start;
  2436.      rtx end;
  2437.      rtx loop_top;
  2438.      int insn_count;
  2439.      rtx loop_start;
  2440.      rtx loop_end;
  2441.      int nregs;
  2442. {
  2443.   rtx p;
  2444.   rtx inc_val;
  2445.   rtx mult_val;
  2446.   int dest_regno;
  2447.   int biv_found;
  2448.   /* This is 1 if current insn could be executed zero times in the loop.  */
  2449.   int maybe_never = 0;
  2450.   /* List of all possible basic induction variables.  */
  2451.   struct iv_class *iv_list = 0;
  2452.   /* Temporary list pointers for traversing iv_list.  */
  2453.   struct iv_class *bl, *backbl;
  2454.   /* Ratio of extra register life span we can justify
  2455.      for saving an instruction.  More if loop doesn't call subroutines
  2456.      since in that case saving an insn makes more difference
  2457.      and more registers are available.  */
  2458.   /* ??? could set this to last value of threshold in move_movables */
  2459.   int threshold = loop_has_call ? 17 : 34;
  2460.   /* Map of pseudo-register replacements.  */
  2461.   rtx *reg_map;
  2462.   int call_seen;
  2463.  
  2464.   induct_var = (enum iv_mode *) alloca (nregs * sizeof (induct_var[0]));
  2465.   bzero ((char *)induct_var, nregs * sizeof (induct_var[0]));
  2466.   induct_struct = (struct induction **)
  2467.     alloca (nregs * sizeof (struct induction *));
  2468.   bzero ((char *)induct_struct, nregs * sizeof (struct induction *));
  2469.   class_struct = (struct iv_class **)
  2470.     alloca (nregs * sizeof (struct iv_class *));
  2471.   bzero ((char *)class_struct, nregs * sizeof (struct iv_class *));
  2472.  
  2473.   /* Scan through loop to find all possible bivs.  */
  2474.  
  2475.   for (p = NEXT_INSN (loop_start); p != end; p = NEXT_INSN (p))
  2476.     {
  2477.       if (GET_CODE (p) == INSN
  2478.       && GET_CODE (PATTERN (p)) == SET
  2479.       && GET_CODE (SET_DEST (PATTERN (p))) == REG)
  2480.     {
  2481.       dest_regno = REGNO (SET_DEST (PATTERN (p)));
  2482.       if (induct_var[dest_regno] != NOT_BASIC_INDUCT
  2483.           && dest_regno >= FIRST_PSEUDO_REGISTER)
  2484.         {
  2485.           if (basic_induction_var (SET_SRC (PATTERN (p)), dest_regno,
  2486.                       &inc_val, &mult_val))
  2487.         {
  2488.           /* It is a possible basic induction variable.
  2489.              Create and initialize an induction structure for it.  */
  2490.  
  2491.           struct induction *v =
  2492.             (struct induction *) alloca (sizeof (struct induction));
  2493.  
  2494.           v->insn = p;
  2495.           v->src_regno = dest_regno;
  2496.           v->dest_regno = dest_regno;
  2497.           v->mult_val = mult_val;
  2498.           v->add_val = inc_val;
  2499.           v->mode = GET_MODE (SET_DEST (PATTERN (p)));
  2500.  
  2501.           /* Add this to the reg's iv_class, creating a class
  2502.              if this is the first incrementation of the reg.  */
  2503.  
  2504.           bl = class_struct[dest_regno];
  2505.           if (bl)
  2506.             {
  2507.               v->family = bl->biv;
  2508.               bl->biv = v;
  2509.               bl->biv_count++;
  2510.             }
  2511.           else
  2512.             {
  2513.               /* Create and initialize new iv_class.  */
  2514.  
  2515.               bl = (struct iv_class *) alloca (sizeof (struct iv_class));
  2516.  
  2517.               bl->regno = dest_regno;
  2518.               bl->biv = v;
  2519.               v->family = 0;
  2520.               bl->giv = 0;
  2521.               bl->biv_count = 1;
  2522.               bl->giv_count = 0;
  2523.  
  2524.               /* Set initial value to the reg itself.  */
  2525.               bl->initial_value = SET_DEST (PATTERN (p));
  2526.               /* We haven't seen the intializing insn yet */
  2527.               bl->init_insn = 0;
  2528.               bl->eliminable = 0;
  2529.               bl->nonneg = 0;
  2530.  
  2531.               /* Add this insn to iv_list.  */
  2532.               bl->next = iv_list;
  2533.               iv_list = bl;
  2534.  
  2535.               /* Put it in the array of iv_lists.  */
  2536.               class_struct[dest_regno] = bl;
  2537.             }
  2538.  
  2539.           induct_var[dest_regno] = BASIC_INDUCT;
  2540.  
  2541.           if (loop_dump_stream)
  2542.             {
  2543.               fprintf (loop_dump_stream,
  2544.                    "Insn %d: possible biv, reg %d,",
  2545.                    INSN_UID (p), dest_regno);
  2546.               if (GET_CODE (inc_val) == CONST_INT)
  2547.             fprintf (loop_dump_stream, " const = %d\n",
  2548.                  INTVAL (inc_val));
  2549.               else
  2550.             {
  2551.               fprintf (loop_dump_stream, " const = ");
  2552.               print_rtl (loop_dump_stream, inc_val);
  2553.               fprintf (loop_dump_stream, "\n");
  2554.             }
  2555.             }
  2556.         }
  2557.           else
  2558.         induct_var[dest_regno] = NOT_BASIC_INDUCT;
  2559.         }
  2560.     }
  2561.     }
  2562.  
  2563.   /* Scan iv_list to remove all regs that proved not to be bivs.
  2564.      Make a sanity check against n_times_set.  */
  2565.  
  2566.   biv_found = 0;
  2567.  
  2568.   for (backbl = bl = iv_list; bl; backbl = bl, bl = bl->next)
  2569.     {
  2570.       if (induct_var[bl->regno] != BASIC_INDUCT)
  2571.     {
  2572.       /* Not a basic induction variable, remove this iv_class.  */
  2573.  
  2574.       if (backbl == bl)
  2575.         iv_list = bl->next;
  2576.       else
  2577.         backbl->next = bl->next;
  2578.  
  2579.       if (loop_dump_stream)
  2580.         fprintf (loop_dump_stream, "Reg %d: biv discarded, not induct\n",
  2581.             bl->regno);
  2582.     }
  2583.       else if (n_times_set[bl->regno] != bl->biv_count)
  2584.     {
  2585.       /* This happens if register modified by subreg, etc.  */
  2586.       /* Make sure it is not recognized as a basic induction var: */
  2587.       /* remove this iv_class from iv_list.  */
  2588.  
  2589.       induct_var[bl->regno] = NOT_BASIC_INDUCT;
  2590.  
  2591.       if (backbl == bl)
  2592.         iv_list = bl->next;
  2593.       else
  2594.         backbl->next = bl->next;
  2595.  
  2596.       if (loop_dump_stream)
  2597.         fprintf (loop_dump_stream, "Reg %d: biv discarded, count error\n",
  2598.             bl->regno);
  2599.     }
  2600.       else
  2601.     {
  2602.       /* This is a valid basic induction variable.  */
  2603.  
  2604.       biv_found++;
  2605.  
  2606.       if (loop_dump_stream)
  2607.         fprintf (loop_dump_stream, "Reg %d: biv verified\n", bl->regno);
  2608.     }
  2609.     }
  2610.  
  2611.   /* Exit if there are no bivs.  */
  2612.   if (!iv_list)
  2613.     return;
  2614.  
  2615.   /* Find initial value for each biv.  */
  2616.   /* Search backwards from loop_start, halting at first label
  2617.      or when all bivs have been seen.  */
  2618.  
  2619.   call_seen = 0;
  2620.   p = loop_start;
  2621.   while (biv_found)
  2622.     {
  2623.       p = PREV_INSN (p);
  2624.       if (p == 0)
  2625.     break;
  2626.  
  2627.       if (GET_CODE (p) == CALL_INSN)
  2628.     call_seen = 1;
  2629.  
  2630.       if (GET_CODE (p) == INSN
  2631.       && GET_CODE (PATTERN (p)) == SET)
  2632.     {
  2633.       rtx dest = SET_DEST (PATTERN (p));
  2634.  
  2635.       while (GET_CODE (dest) == SUBREG
  2636.          || GET_CODE (dest) == ZERO_EXTRACT
  2637.          || GET_CODE (dest) == SIGN_EXTRACT
  2638.          || GET_CODE (dest) == STRICT_LOW_PART)
  2639.         dest = XEXP (dest, 0);
  2640.  
  2641.       if (GET_CODE (dest) == REG)
  2642.         {
  2643.           int dest_regno = REGNO (dest);
  2644.           if (induct_var[dest_regno] == BASIC_INDUCT
  2645.           && class_struct[dest_regno]->init_insn == 0)
  2646.         {
  2647.           /* This is the first modification found for this reg.  */
  2648.  
  2649.           rtx src = SET_SRC (PATTERN (p));
  2650.  
  2651.           /* Record the intializing INSN */
  2652.  
  2653.           class_struct[dest_regno]->init_insn = p;
  2654.  
  2655.           if (loop_dump_stream)
  2656.             fprintf (loop_dump_stream, "Biv %d initialized at insn %d: ",
  2657.                  dest_regno, INSN_UID (p));
  2658.  
  2659.           /* Save value if it is a constant or register.  */
  2660.           if (CONSTANT_P (src)
  2661.               || (GET_CODE (src) == REG
  2662.               /* Don't try to use a value in a hard reg
  2663.                  across a call which clobbers it.  */
  2664.               && ! (REGNO (src) < FIRST_PSEUDO_REGISTER
  2665.                 && call_used_regs[REGNO (src)]
  2666.                 && call_seen)
  2667.               && ! reg_set_between_p (src, p, loop_start)))
  2668.             {
  2669.               class_struct[dest_regno]->initial_value = src;
  2670.  
  2671.               if (loop_dump_stream)
  2672.             fprintf (loop_dump_stream, "initial value ");
  2673.               if (loop_dump_stream)
  2674.             {
  2675.               if (GET_CODE (src) == CONST_INT)
  2676.                 fprintf (loop_dump_stream, "%d\n", INTVAL (src));
  2677.               else
  2678.                 {
  2679.                   print_rtl (loop_dump_stream, src);
  2680.                   fprintf (loop_dump_stream, "\n");
  2681.                 }
  2682.             }
  2683.             }
  2684.           else
  2685.             {
  2686.               /* Biv initial value is not simple move,
  2687.              so let it keep intial value of "itself".  */
  2688.  
  2689.               if (loop_dump_stream)
  2690.             fprintf (loop_dump_stream, "complex initial value\n");
  2691.             }
  2692.  
  2693.           biv_found--;
  2694.         }
  2695.         }
  2696.     }
  2697.       else if (GET_CODE (p) == CODE_LABEL)
  2698.     break;
  2699.     }
  2700.  
  2701.   /* Search the loop for general induction variables.  */
  2702.  
  2703.   /* A register is a giv if: it is only set once, it is a function of a
  2704.      biv and a constant (or invariant), and it is not a biv.  */
  2705.  
  2706.   p = scan_start;
  2707.   while (1)
  2708.     {
  2709.       p = NEXT_INSN (p);
  2710.       /* At end of a straight-in loop, we are done.
  2711.      At end of a loop entered at the bottom, scan the top.  */
  2712.       if (p == scan_start)
  2713.     break;
  2714.       if (p == end)
  2715.     {
  2716.       if (loop_top != 0)
  2717.         p = NEXT_INSN (loop_top);
  2718.       else
  2719.         break;
  2720.       if (p == scan_start)
  2721.         break;
  2722.     }
  2723.  
  2724.       /* Look for a general induction variable in a register.  */
  2725.       if (GET_CODE (p) == INSN
  2726.       && GET_CODE (PATTERN (p)) == SET
  2727.       && GET_CODE (SET_DEST (PATTERN (p))) == REG)
  2728.     {
  2729.       int src_regno;
  2730.       rtx add_val;
  2731.       rtx mult_val;
  2732.       int benefit;
  2733.       rtx regnote = 0;
  2734.       struct induction *forces = 0;
  2735.       struct induction *forces2 = 0;
  2736.  
  2737.       dest_regno = REGNO (SET_DEST (PATTERN (p)));
  2738.       if (dest_regno < FIRST_PSEUDO_REGISTER)
  2739.         continue;
  2740.  
  2741.       if (/* Normal giv.  */
  2742.           ((benefit = general_induction_var (SET_SRC (PATTERN (p)),
  2743.                          &src_regno, &add_val,
  2744.                          &mult_val,
  2745.                          &forces, &forces2))
  2746.            /* Giv set with call to a library routine.  */
  2747.            || ((regnote = find_reg_note (p, REG_EQUAL, 0))
  2748.            &&
  2749.            (benefit = general_induction_var (XEXP (regnote, 0),
  2750.                              &src_regno,
  2751.                              &add_val, &mult_val,
  2752.                              &forces, &forces2))))
  2753.           /* Don't try to handle any regs made by loop optimization.
  2754.          We have nothing on them in regno_first_uid, etc.  */
  2755.           && dest_regno < old_max_reg
  2756.           /* Don't recognize a BASIC_INDUCT_VAR here.  */
  2757.           && dest_regno != src_regno
  2758.           /* This must be the only place where the register is set.  */
  2759.           && (n_times_set[dest_regno] == 1
  2760.           || (benefit = consec_sets_giv (benefit, p,
  2761.                          src_regno, dest_regno,
  2762.                          &add_val, &mult_val))))
  2763.         {
  2764.           int count;
  2765.           struct induction *v =
  2766.         (struct induction *) alloca (sizeof (struct induction));
  2767.           rtx temp;
  2768.  
  2769.           record_giv (v, p, src_regno, dest_regno, mult_val, add_val, benefit,
  2770.               forces, forces2, DEST_REG, maybe_never, 0, loop_end);
  2771.  
  2772.           /* Skip the consecutive insns, if there are any.  */
  2773.           for (count = v->consec - 1; count >= 0; count--)
  2774.         {
  2775.           /* If first insn of libcall sequence, skip to end.  */
  2776.           /* Do this at start of loop, since INSN is guaranteed to
  2777.              be an insn here.  */
  2778.           if (temp = find_reg_note (p, REG_LIBCALL, 0))
  2779.             {
  2780.               /* Eliminating a libcall does more good than
  2781.              eliminating a single insn to do the same job.  */
  2782.               benefit += LIBCALL_BENEFIT;
  2783.               p = XEXP (temp, 0);
  2784.             }
  2785.  
  2786.           do p = NEXT_INSN (p);
  2787.           while (GET_CODE (p) == NOTE);
  2788.         }
  2789.         }
  2790.     }
  2791.  
  2792. #ifndef DONT_REDUCE_ADDR
  2793.       /* Look for givs which are memory addresses.  */
  2794.       /* This resulted in worse code on a VAX 8600.  I wonder if it
  2795.      still does.  */
  2796.       if (GET_CODE (p) == INSN)
  2797.     find_mem_givs (PATTERN (p), p, maybe_never, loop_end);
  2798. #endif
  2799.  
  2800.       /* Past a label or a jump, we get to insns for which we can't count
  2801.      on whether or how many times they will be executed during each
  2802.      iteration.  Givs found afterwards cannot be marked replaceable.  */
  2803.       if (GET_CODE (p) == CODE_LABEL || GET_CODE (p) == JUMP_INSN)
  2804.     maybe_never = 1;
  2805.     }
  2806.  
  2807.   /* Try to prove that the loop counter variable (if any) is always
  2808.      nonnegative; if so, record that fact with a REG_NONNEG note
  2809.      so that "decrement and branch until zero" insn can be used.  */
  2810.   check_dbra_loop (loop_end, iv_list, insn_count, loop_start);
  2811.  
  2812.   /* Create reg_map to hold substitutions for replaceable giv regs.  */
  2813.   reg_map = (rtx *) alloca (nregs * sizeof (rtx));
  2814.   bzero ((char *)reg_map, nregs * sizeof (rtx));
  2815.  
  2816.   /* Examine each iv class for feasibility of strength reduction/induction
  2817.      variable elimination.  */
  2818.  
  2819.   for (bl = iv_list; bl; bl = bl->next)
  2820.     {
  2821.       struct induction *v;
  2822.       int benefit;
  2823.       int replaceable;
  2824.       int all_reduced;
  2825.       rtx final_value = 0;
  2826.  
  2827.       /* Test whether it will be possible to eliminate this biv
  2828.      provided all givs are reduced.  This is possible if either
  2829.      the reg is not used outside the loop, or we can compute
  2830.      what its final value will be.
  2831.  
  2832.      Don't try if we put a REG_NONNEG note on the endtest for this biv.
  2833.      ??? That should be only on machines that have dbra insns.  */
  2834.  
  2835.       /* Compare against bl->init_insn rather than loop_start.
  2836.      We aren't concerned with any uses of the biv between
  2837.      init_insn and loop_start since these won't be affected
  2838.      by the value of the biv elsewhere in the function, so
  2839.      long as init_insn doesn't use the biv itself.
  2840.      March 14, 1989 -- self@bayes.arc.nasa.gov */
  2841.  
  2842.       if ((uid_luid[regno_last_uid[bl->regno]] < INSN_LUID (loop_end)
  2843.        && bl->init_insn
  2844.        && INSN_UID (bl->init_insn) < max_uid
  2845.        && uid_luid[regno_first_uid[bl->regno]] >= INSN_LUID (bl->init_insn)
  2846.        && ! reg_mentioned_p (SET_DEST (PATTERN (bl->biv->insn)),
  2847.                  SET_SRC (PATTERN (bl->init_insn)))
  2848.        && ! bl->nonneg)
  2849.       || (final_value = final_biv_value (bl, loop_end)))
  2850.     check_eliminate_biv (bl, loop_start, end);
  2851.       else
  2852.     {
  2853.       if (loop_dump_stream)
  2854.         {
  2855.           fprintf (loop_dump_stream,
  2856.                "Cannot eliminate biv %d.\n",
  2857.                bl->regno);
  2858.           fprintf (loop_dump_stream,
  2859.                "First use: insn %d, last use: insn %d.\n",
  2860.                regno_first_uid[bl->regno],
  2861.                regno_last_uid[bl->regno]);
  2862.         }
  2863.     }
  2864.  
  2865.       /* This will be true at the end, if all givs which depend on this
  2866.      biv have been strength reduced.
  2867.      We can't (currently) eliminate the biv unless this is so.  */
  2868.       all_reduced = 1;
  2869.  
  2870.       /* Check each giv in this class.  */
  2871.  
  2872.       for (v = bl->giv; v; v = v->family)
  2873.     {
  2874.       struct induction *tv;
  2875.  
  2876.       if (v->ignore)
  2877.         continue;
  2878.  
  2879.       benefit = v->benefit;
  2880.       replaceable = v->replaceable;
  2881.  
  2882.       /* Reduce benefit if not replaceable, since we will insert
  2883.          a move-insn to replace the insn that calculates this giv.  */
  2884.       if (!replaceable && ! bl->eliminable)
  2885.         benefit -= COPY_PENALTY;
  2886.  
  2887.       /* Decrease the benefit to count the add-insns that we will
  2888.          insert to increment the reduced reg for the giv.  */
  2889.       benefit -= ADD_BENEFIT * bl->biv_count;
  2890.  
  2891.       /* Find all equivalent givs (that bear same relation to the biv).
  2892.          Link them via the `same' field and add their benefits together.
  2893.          They can be replaced with a single register.  */
  2894.  
  2895.       for (tv = v->family; tv; tv = tv->family)
  2896.         {
  2897.           if (tv->ignore == 0
  2898.           && tv->src_regno == v->src_regno
  2899.           && rtx_equal_p (tv->mult_val, v->mult_val)
  2900.           && rtx_equal_p (tv->add_val, v->add_val))
  2901.         {
  2902.           benefit += tv->benefit;
  2903.           if (! tv->replaceable)
  2904.             benefit -= COPY_PENALTY;
  2905.           v->lifetime += tv->lifetime;
  2906.           v->times_used += tv->times_used;
  2907.           tv->ignore = 1;
  2908.  
  2909.           /* Link them together via `same' field.  */
  2910.           tv->same = v->same;
  2911.           v->same = tv;
  2912.  
  2913.           if (loop_dump_stream)
  2914.             fprintf (loop_dump_stream,
  2915.                  "giv of insn %d combined with that of %d.\n",
  2916.                  INSN_UID (v->insn), INSN_UID (tv->insn));
  2917.         }
  2918.         }
  2919.  
  2920.       /* Decide whether to strength-reduce this giv
  2921.          or to leave the code unchanged
  2922.          (recompute it from the biv each time it is used).
  2923.          This decision can be made independently for each giv.  */
  2924.  
  2925.       /* ??? Perhaps attempt to guess whether autoincrement will handle
  2926.          some of the new add insns; if so, can increase BENEFIT
  2927.          (undo the subtraction of ADD_BENEFIT that was done above).  */
  2928.  
  2929.       /* If an insn is not to be strength reduced, then set its ignore
  2930.          flag, and clear all_reduced.  */
  2931.  
  2932.       /* Is it right to consider times_used?  */
  2933.  
  2934.       /* ??? What about the insns that are 'forced' by this one?
  2935.          Although this insn is not worthwhile to reduce, it may be
  2936.          worthwhile to reduce the simpler givs used to compute this 
  2937.          complex giv.  */
  2938.  
  2939.       /* ??? Hey! If a giv has its forces field set, then that means
  2940.          it is not computed directly from the biv, it is instead computed
  2941.          from a simpler giv.  If we define UNFORCE_INSNS, then the simpler
  2942.          giv will be considered for strength reduction, and this giv should
  2943.          not cause all_reduced to be cleared because it DOESN'T use the
  2944.          biv!!!  If the simpler giv can not be reduced, then that simpler
  2945.          biv will still cause all_reduced to be cleared.  */
  2946.  
  2947.       if (benefit <= 0)
  2948.         {
  2949.           if (loop_dump_stream)
  2950.         fprintf (loop_dump_stream, "giv of insn %d, no benefit\n",
  2951.              INSN_UID (v->insn));
  2952.           v->ignore = 1;
  2953.           all_reduced = 0;
  2954.         }
  2955.  
  2956.       if (v->lifetime * threshold * benefit < insn_count)
  2957.         {
  2958.           if (loop_dump_stream)
  2959.         fprintf (loop_dump_stream,
  2960.              "giv of insn %d not worth while, %d vs %d.\n",
  2961.              INSN_UID (v->insn),
  2962.              v->lifetime * threshold * benefit, insn_count);
  2963.           v->ignore = 1;
  2964.           all_reduced = 0;
  2965.         }
  2966.  
  2967.       /* Now check that we can increment the reduced giv
  2968.          without needing a multiply insn.  If not, reject it.  */
  2969.  
  2970.       if (! v->ignore)
  2971.         {
  2972.           int success = 1;
  2973.  
  2974.           for (tv = bl->biv; tv; tv = tv->family)
  2975.         if (tv->mult_val == const1_rtx)
  2976.           success &= product_cheap_p (tv->add_val, v->mult_val);
  2977.  
  2978.           if (! success)
  2979.         {
  2980.           if (loop_dump_stream)
  2981.             fprintf (loop_dump_stream,
  2982.                  "giv of insn %d: would need a multiply.\n",
  2983.                  INSN_UID (v->insn));
  2984.           v->ignore = 1;
  2985.           all_reduced = 0;
  2986.         }
  2987.         }
  2988.     }
  2989.  
  2990.       /* Reduce each giv that we decided to reduce.  */
  2991.  
  2992.       for (v = bl->giv; v; v = v->family)
  2993.     {
  2994.       struct induction *tv;
  2995.       if (! v->ignore)
  2996.         {
  2997.           rtx new_reg;
  2998.  
  2999.           /* Note Iris compiler dies if ?: is used inside gen_reg_rtx. */
  3000.           if (v->giv_type == DEST_ADDR)
  3001.             new_reg = gen_reg_rtx (Pmode);
  3002.           else
  3003.             new_reg = gen_reg_rtx (GET_MODE (SET_DEST (PATTERN (v->insn))));
  3004.  
  3005.           /* For each place where the biv is incremented,
  3006.          add an insn to increment the new, reduced reg for the giv.
  3007.          Insert it before the insn that sets the biv,
  3008.          so that the biv increment remains last before the endtest,
  3009.          so that dbra will still be recognized.  */
  3010.  
  3011.           for (tv = bl->biv; tv; tv = tv->family)
  3012.         {
  3013.           struct induction *iv;
  3014.           rtx before_insn = tv->insn;
  3015.  
  3016.           /* If this increment is between the setting of the giv and
  3017.              its use, don't increment until after the use.  */
  3018.           for (iv = v; iv; iv = iv->same)
  3019.             {
  3020.               if (INSN_LUID (tv->insn) <= INSN_LUID (iv->insn)
  3021.               && ((iv->forces
  3022.                    && (INSN_LUID (tv->insn)
  3023.                    >= INSN_LUID (iv->forces->insn))
  3024.                   || (iv->forces2
  3025.                   && (INSN_LUID (tv->insn)
  3026.                       >= INSN_LUID (iv->forces2->insn))))))
  3027.             {
  3028.               before_insn = NEXT_INSN (iv->insn);
  3029.               break;
  3030.             }
  3031.             }
  3032.  
  3033.           if (tv->mult_val == const1_rtx)
  3034.             emit_iv_inc (tv->add_val, v->mult_val,
  3035.                  new_reg, before_insn);
  3036.           else /* tv->mult_val == const0_rtx */
  3037.             /* A multiply is acceptable here
  3038.                since this is presumed to be seldom executed.  */
  3039.             emit_iv_init_code (tv->add_val, v->mult_val,
  3040.                        v->add_val, new_reg, before_insn);
  3041.         }
  3042.  
  3043.           /* Add code at loop start to initialize giv's reduced reg.  */
  3044.  
  3045.           emit_iv_init_code (bl->initial_value, v->mult_val,
  3046.                  v->add_val, new_reg, loop_start);
  3047.           /* If the initial value uses a register,
  3048.          then we may have just extended its range of appearance.
  3049.          Update this conservatively for the sake of outer loops.  */
  3050.           if (GET_CODE (bl->initial_value) == REG
  3051.           && (uid_luid[regno_last_uid[REGNO (bl->initial_value)]]
  3052.               < INSN_LUID (loop_start)))
  3053.         uid_luid[regno_last_uid[REGNO (bl->initial_value)]]
  3054.           = INSN_LUID (loop_start);
  3055.  
  3056.           /* For each giv register that can be reduced now:
  3057.          delete old insn that modifies the giv,
  3058.          if replaceable, substitute reduced reg
  3059.            wherever the old giv occurs;
  3060.          else add new move insn "giv_reg = reduced_reg".  */
  3061.  
  3062.           for (tv = v; tv; tv = tv->same)
  3063.         {
  3064.           /* Record the identity of the reduced reg.  */
  3065.           tv->new_reg = new_reg;
  3066.  
  3067.           if (tv->giv_type == DEST_ADDR)
  3068.             {
  3069.               /* Store reduced reg as the address in the memref
  3070.              where we found this giv.  */
  3071.               * tv->location = new_reg;
  3072.             }
  3073.           else if (tv->replaceable)
  3074.             {
  3075.               reg_map[tv->dest_regno] = new_reg;
  3076.               /* If giv lives after end of loop,
  3077.              emit insn to copy reduced reg into old reg,
  3078.              at the end of the loop.
  3079.              ?? insufficient; used before loop could
  3080.              mean live after loop, due to surrounding loop.  */
  3081.               /* Currently a giv used outside
  3082.              the loop will not be marked replaceable,
  3083.              so these deficiencies don't really hurt.  */
  3084.               if (uid_luid[regno_last_uid[tv->dest_regno]]
  3085.               > uid_luid[INSN_UID (loop_end)])
  3086.             {
  3087.               /* ?? This won't work.  We need to do this at
  3088.                  ALL exits.  */
  3089.               emit_insn_after (gen_rtx (SET, VOIDmode,
  3090.                             SET_DEST (PATTERN (tv->insn)),
  3091.                             new_reg),
  3092.                        loop_end);
  3093.               abort ();
  3094.             }
  3095.             }
  3096.           else
  3097.             {
  3098.               /* Not replaceable; emit an insn to set the
  3099.              original giv reg from the reduced giv.  */
  3100.  
  3101.               int count;
  3102.               rtx after_insn = tv->insn;
  3103.  
  3104.               for (count = tv->consec; count > 0; count--)
  3105.             after_insn = next_real_insn (after_insn);
  3106.  
  3107.               /* Put new insn after, not before, in case
  3108.              after_insn is the end of a libcall.  */
  3109.               emit_insn_after (gen_rtx (SET, VOIDmode,
  3110.                         SET_DEST (PATTERN (tv->insn)),
  3111.                         new_reg),
  3112.                        after_insn);
  3113.             }
  3114.  
  3115.           /* Delete the insn that used to set the old giv reg,
  3116.              unless we modified an address in it.
  3117.              In any case, delete the other insns used for this one.  */
  3118.           delete_insn_forces (tv, tv->giv_type != DEST_ADDR);
  3119.  
  3120.           if (loop_dump_stream)
  3121.             fprintf (loop_dump_stream, "giv at %d reduced to reg %d\n",
  3122.                  INSN_UID (tv->insn), REGNO (new_reg));
  3123.         }
  3124.           /* One set of equivalent givs has been strength-reduced.  */
  3125.         }
  3126. #if 0
  3127.       else if (v->new_reg == 0)
  3128.         {
  3129.           /* This giv wasn't reduced and is not worth reducing.  */
  3130.  
  3131.           for (tv = v; tv; tv = tv->same)
  3132.         if (loop_dump_stream)
  3133.           fprintf (loop_dump_stream, "giv at %d not reduced\n",
  3134.                INSN_UID (tv->insn));
  3135.  
  3136.           all_reduced = 0;
  3137.         }
  3138. #endif
  3139.     }
  3140.  
  3141.       /* All the givs in this family have been reduced if they merit it.  */
  3142.  
  3143.       /* Try to eliminate the biv, if it is a candidate.
  3144.      This won't work if ! all_reduced,
  3145.      since the givs we planned to use might not have been reduced.  */
  3146.  
  3147.       if (all_reduced == 1 && bl->eliminable)
  3148.     {
  3149.       /* Get the REG rtx for the biv.  */
  3150.       rtx reg = SET_DEST (PATTERN (bl->biv->insn));
  3151.  
  3152.       for (p = loop_start; p != end; p = NEXT_INSN (p))
  3153.         {
  3154.           enum rtx_code code = GET_CODE (p);
  3155.           if ((code == INSN || code == JUMP_INSN || code == CALL_INSN)
  3156.           && reg_mentioned_p (reg, PATTERN (p))
  3157.           && SET_DEST (PATTERN (p)) == cc0_rtx)
  3158.         /* Found a compare instruction using this biv;
  3159.            rewrite it to use a related giv.  */
  3160.         {
  3161.           struct induction *v1;
  3162.           /* If this is an insn which uses the biv ONLY in the
  3163.              calculation of a giv which is in the family of this
  3164.              biv, it's ok becuase it will go away when the giv is
  3165.              reduced.  */
  3166.           for (v1 = bl->giv; v1; v1 = v1->family)
  3167.             if (v1->insn == p)
  3168.               {
  3169.             if (v1->giv_type == DEST_REG
  3170.                 || (v1->giv_type == DEST_ADDR
  3171.                 /* Test was backwards - rms, 5 Dec 89 */
  3172.                 && only_reg_use_p (reg, *(v1->location),
  3173.                            PATTERN (p))))
  3174.               break;
  3175.               }
  3176.           if (!v1)
  3177.             eliminate_biv (p, bl, loop_start);
  3178.         }
  3179.         }
  3180.  
  3181.       /* Biv is no longer really needed inside the loop,
  3182.          so delete all insns that set the biv.  */
  3183.  
  3184.       for (v = bl->biv; v; v = v->family)
  3185.         delete_insn (v->insn);
  3186.  
  3187.       /* ?? If we created a new test to bypass the loop entirely,
  3188.          or otherwise drop straight in, based on this test, then
  3189.          we might want to rewrite it also.  This way some later
  3190.          pass has more hope of removing the intialization of this
  3191.          biv entirely. */
  3192.  
  3193.       /* If final_value != 0, then biv may be used after loop end
  3194.          and we must emit an insn to set it just in case.  */
  3195.       if (final_value != 0)
  3196.         emit_insn_after (gen_rtx (SET, VOIDmode, reg, final_value),
  3197.                  loop_end);
  3198.  
  3199.       if (loop_dump_stream)
  3200.         fprintf (loop_dump_stream, "Reg %d: biv eliminated\n",
  3201.              bl->regno);
  3202.     }
  3203.     }
  3204.  
  3205.   /* Go through all the instructions in the loop, making all the
  3206.      register substitutions scheduled in REG_MAP.  */
  3207.  
  3208.   for (p = loop_start; p != end; p = NEXT_INSN (p))
  3209.     if (GET_CODE (p) == INSN || GET_CODE (p) == JUMP_INSN
  3210.      || GET_CODE (p) == CALL_INSN)
  3211.       replace_regs (PATTERN (p), reg_map, nregs);
  3212.  
  3213.   if (loop_dump_stream)
  3214.     fprintf (loop_dump_stream, "\n");
  3215. #if defined( DSP96000 ) || defined( DSP56000 )
  3216.   if ( TARGET_LINV_PLUS_BIV_PROMOTION )
  3217.   {
  3218.       rtx scan_back = loop_end;
  3219.  
  3220.       /* scan from the end of the loop forward. */
  3221.       for ( ; loop_start != scan_back ; scan_back = PREV_INSN ( scan_back ))
  3222.       {
  3223.       /* MEM rtx with + expr address. */
  3224.       rtx mem_ref; 
  3225.       /* PLUS expr which is the MEM arg. */
  3226.       rtx add_expr = NULL;
  3227.       /* INSN rtx of original computation of the address. */
  3228.       rtx indirect_insn = NULL, indirect_reg;
  3229.       /* secondary scan pointer. */
  3230.       rtx peek = NULL;
  3231.       /* the loop invariant, the basic induction variable.
  3232.        * prior_... is the operand before it was striped of subregs.
  3233.        */
  3234.       rtx linv = NULL, biv = NULL, prior_linv, prior_biv;
  3235.       /* the analog pointer register */
  3236.       rtx analog;
  3237.       /* the increment or decrement value */
  3238.       rtx biv_increment;
  3239.       
  3240.       /* we only consider insns which ref memory. */
  3241.       if (( INSN != GET_CODE ( scan_back )) ||
  3242.           ( NULL == ( mem_ref = find_mem ( PATTERN ( scan_back )))))
  3243.       {
  3244.           continue;
  3245.       }
  3246.  
  3247.       /* since we don't have data-flow info yet, look back thru this 
  3248.        * block and see if we can find the definition of the address reg.
  3249.        * we don't do hard regs yet.
  3250.        */
  3251.       if ( REG == GET_CODE ( indirect_reg = XEXP ( mem_ref, 0 )))
  3252.       {
  3253.           /* bail if this is a hard reg. It may be set by a call. */
  3254.           if ( REGNO ( indirect_reg ) < FIRST_PSEUDO_REGISTER )
  3255.           {
  3256.           continue;
  3257.           }
  3258.           
  3259.           for ( peek = PREV_INSN ( scan_back );
  3260.            ( peek != loop_start ) && 
  3261.            ( CODE_LABEL != GET_CODE ( peek )) &&
  3262.            ( BARRIER != GET_CODE ( peek )) &&
  3263.            ( JUMP_INSN != GET_CODE ( peek ));
  3264.            peek = PREV_INSN ( peek ))
  3265.           {
  3266.           if (( INSN == GET_CODE ( peek )) &&
  3267.               ( SET == GET_CODE ( PATTERN ( peek ))) &&
  3268.               ( indirect_reg == SET_DEST ( PATTERN ( peek ))))
  3269.           {
  3270.               add_expr = SET_SRC ( PATTERN ( peek ));
  3271.               break;
  3272.           }
  3273.           }
  3274.           
  3275.           /* couldn't find the definition of the address register. */
  3276.           if ( NULL == add_expr )
  3277.           {
  3278.           continue;
  3279.           }
  3280.       }
  3281.       else
  3282.       {
  3283.           /* otherwise, the address of the mem-ref is the expr we're 
  3284.            * looking for.
  3285.            */
  3286.           add_expr = XEXP ( mem_ref, 0 );
  3287.       }
  3288.       if ( PLUS != GET_CODE ( add_expr ))
  3289.       {
  3290.           continue;
  3291.       }
  3292.       /* ok - we have a MEM with an address that consists of a PLUS 
  3293.        * expression. we now need to show that one of the operands is
  3294.        * a loop invariant, and that the other is a basic induction 
  3295.        * variable. find the linv first.
  3296.        */
  3297.       
  3298.       /* deal with subregs. */
  3299.       prior_linv = ( linv = XEXP ( add_expr, 0 ));
  3300.       if ( SUBREG == GET_CODE ( linv ))
  3301.       {
  3302.           linv = XEXP ( linv, 0 );
  3303.       }
  3304.       
  3305.       switch ( GET_CODE ( linv ))
  3306.       {
  3307.       case SYMBOL_REF:
  3308.       case CONST:
  3309.       case CONST_INT:
  3310.           /* by setting the biv, we indicate that we have found linv */
  3311.           prior_biv = ( biv = XEXP ( add_expr, 1 ));
  3312.           break;
  3313.           
  3314.       case REG:
  3315.           if ( ! reg_set_between_p ( linv, loop_start, loop_end ))
  3316.           {
  3317.           /* although a reg, it is inv in the loop. */
  3318.           prior_biv = ( biv = XEXP ( add_expr, 1 ));
  3319.           }
  3320.           else 
  3321.           {
  3322.           /* the 0th arg isn't the linv. try the 1th. */
  3323.           prior_linv = ( linv = XEXP ( add_expr, 1 ));
  3324.           }
  3325.           break;
  3326.           
  3327.       default:
  3328.           /* give up. */
  3329.           linv = 0;
  3330.       }
  3331.  
  3332.       /* we have an unknown in the + expr: bail out. */
  3333.       if ( ! linv )
  3334.       {
  3335.           continue;
  3336.       }
  3337.  
  3338.       /* we need to check the other operand and see if it is a viable
  3339.        * linv. 
  3340.        */
  3341.       if ( ! biv )
  3342.       {
  3343.           /* check for subregs again. */
  3344.           if ( SUBREG == GET_CODE ( linv ))
  3345.           {
  3346.           linv = XEXP ( linv, 0 );
  3347.           }
  3348.           
  3349.           switch ( GET_CODE ( linv ))
  3350.           {
  3351.           case REG:
  3352.           if ( reg_set_between_p ( linv, loop_start, loop_end ))
  3353.           {
  3354.               break;
  3355.           }
  3356.           /* otherwise drop thru ... */
  3357.           
  3358.           case SYMBOL_REF:
  3359.           case CONST:
  3360.           case CONST_INT:
  3361.           /* by setting the biv, we indicate that we have found linv */
  3362.           prior_biv = ( biv = XEXP ( add_expr, 0 ));
  3363.           }
  3364.       }
  3365.       if ( ! biv )
  3366.       {
  3367.           continue;
  3368.       }
  3369.       /* maybe subreg again ? */
  3370.       if ( SUBREG == GET_CODE ( biv ))
  3371.       {
  3372.           biv = XEXP ( biv, 0 );
  3373.       }
  3374.       
  3375.       /* this biv could just be a copy of a real biv via a subreg due
  3376.        * to mode considerations. we need to find the best_equiv for 
  3377.        * biv because if the biv we have is really a copy, then induct_var
  3378.        * and class_struct will not be set properly for the copy. 
  3379.        */
  3380.  
  3381.           {
  3382.           rtx tmp = find_best_equiv ( biv, scan_back, loop_start );
  3383.           
  3384.           if ( tmp )
  3385.           {
  3386.           biv = tmp;
  3387.           }
  3388.       }
  3389.       
  3390.       if (( REG != GET_CODE ( biv )) ||
  3391.           ( BASIC_INDUCT != induct_var[ REGNO ( biv ) ]))
  3392.       {
  3393.           /* we have failed to find a linv and biv. */
  3394.           continue;
  3395.       }
  3396.  
  3397.       /* the GNU biv info really isn't reliable. we need a more stringent
  3398.        * set of constraints.
  3399.        */
  3400.  
  3401.           {
  3402.           rtx label = loop_start, jump = loop_end;
  3403.  
  3404.           while ( label && ( NOTE == GET_CODE ( label )))
  3405.           {
  3406.           label = NEXT_INSN ( label );
  3407.           }
  3408.           if (( ! label ) || ( CODE_LABEL != GET_CODE ( label )))
  3409.           {
  3410.           continue;
  3411.           }
  3412.           
  3413.           while ( jump && ( NOTE == GET_CODE ( jump )))
  3414.           {
  3415.           jump = PREV_INSN ( jump );
  3416.           }
  3417.           if (( ! jump ) || ( JUMP_INSN != GET_CODE ( jump )))
  3418.           {
  3419.           continue;
  3420.           }
  3421.  
  3422.           if ( ! biv_qualified_p ( biv, NEXT_INSN ( label ),
  3423.                       PREV_INSN ( jump )))
  3424.           {
  3425.           continue;
  3426.           }
  3427.       }
  3428.       
  3429.       /* now we need to know whether the biv is inc/dec'ed before or
  3430.        * after it's use here. ( here is @ peek ( if it is defined ), or
  3431.        * @ scan_back ). Since we don't have full data flow info, if
  3432.        * we run into a BARRIER, JUMP_INSN, or CODE_LABEL, then we punt.
  3433.        */
  3434.  
  3435.       indirect_insn = peek;
  3436.       if ( ! peek )
  3437.       {
  3438.           peek = PREV_INSN ( scan_back );
  3439.       }
  3440.       else /* the indirect insn could actually be a biv inc ! */
  3441.       {
  3442.           peek = PREV_INSN ( peek );
  3443.       }
  3444.       
  3445.       while (( NULL != peek ) && ( loop_start != peek ))
  3446.       {
  3447.           if (( BARRIER == GET_CODE ( peek )) ||
  3448.           ( JUMP_INSN == GET_CODE ( peek )) ||
  3449.           (( CODE_LABEL == GET_CODE ( peek )) &&
  3450.            ( loop_start != PREV_INSN ( peek ))))
  3451.           {
  3452.           peek = NULL;
  3453.           break;
  3454.           }
  3455.           if (( INSN == GET_CODE ( peek )) &&
  3456.           ( SET == GET_CODE ( PATTERN ( peek ))) &&
  3457.           ( biv == SET_DEST ( PATTERN ( peek ))))
  3458.           {
  3459.           break;
  3460.           }
  3461.           peek = PREV_INSN ( peek );
  3462.       }
  3463.       if ( NULL == peek )
  3464.       {
  3465.           continue;
  3466.       }
  3467.  
  3468.       /* sometimes a constant will get CSE'ed out of an increment, because
  3469.        * constants are, in general, expensive. we need to see whether the
  3470.        * biv inc/dec modifier is actually a constant.
  3471.        */
  3472.       biv_increment = class_struct[ REGNO ( biv ) ]->biv->add_val;
  3473.  
  3474.       if ( CONST_INT != GET_CODE ( biv_increment ))
  3475.       {
  3476.           rtx tmp = loop_start;
  3477.  
  3478.           while (( PREV_INSN ( tmp )) &&
  3479.              ( CODE_LABEL != GET_CODE ( tmp )) &&
  3480.              ( JUMP_INSN != GET_CODE ( tmp )))
  3481.           {
  3482.           tmp = PREV_INSN ( tmp );
  3483.           }
  3484.           
  3485.           if (( REG != GET_CODE ( biv_increment )) ||
  3486.           reg_set_between_p ( biv_increment, loop_start, loop_end ))
  3487.           {
  3488.           continue;
  3489.           }
  3490.           biv_increment =
  3491.           find_best_equiv ( biv_increment, loop_start, tmp );
  3492.       
  3493.           if (( ! biv_increment ) ||
  3494.           ( CONST_INT != GET_CODE ( biv_increment )))
  3495.           {
  3496.           continue;
  3497.           }
  3498.       }
  3499.       
  3500.       /* we can only handle inc/dec by 1 with (r)+/- addr modes. */
  3501.       if (( 1 != INTVAL ( biv_increment )) &&
  3502.           ( -1 != INTVAL ( biv_increment )))
  3503.       {
  3504.           continue;
  3505.       }
  3506.       
  3507.       /* if loop_start == peek, the biv update must take place after 
  3508.        * our use. create an analog biv and initialize it right before
  3509.        * loop_start. replace our use of the add_sub_expr with the new
  3510.        * analog iv, and place it's inc/dec right after the insn where
  3511.        * it is used.
  3512.        */
  3513.  
  3514.       analog = gen_reg_rtx ( Pmode );
  3515.       XEXP ( mem_ref, 0 ) = analog;
  3516.  
  3517.       /* we need to create the original add_expr in terms of the 
  3518.        * best_equiv linv and biv, along with any subregs needed. 
  3519.        * prior_... will be used to determine whether a subreg for ...
  3520.        * is needed, and also the mode (if needed).
  3521.        */
  3522.       add_expr = gen_rtx ( PLUS, Pmode,
  3523.                   ((( prior_biv == biv ) ||
  3524.                 ( prior_biv->mode == biv->mode )) ? biv :
  3525.                    gen_rtx ( SUBREG, prior_biv->mode, biv )),
  3526.                   ((( prior_linv == linv ) ||
  3527.                 ( prior_linv->mode == linv->mode )) ? linv :
  3528.                    gen_rtx ( SUBREG, prior_linv->mode, linv )));
  3529.       
  3530.       if ( 0 > INTVAL ( biv_increment ))
  3531.       {
  3532.           emit_insn_after ( 
  3533.                    gen_rtx ( SET, VOIDmode, analog,
  3534.                     gen_rtx ( MINUS, Pmode, analog, 
  3535.                          const1_rtx )),
  3536.                    scan_back );
  3537.       }
  3538.       else
  3539.       {
  3540.           emit_insn_after ( 
  3541.                    gen_rtx ( SET, VOIDmode, analog,
  3542.                     gen_rtx ( PLUS, Pmode, analog,
  3543.                          const1_rtx )),
  3544.                    scan_back );
  3545.       }
  3546.       
  3547.       if ( loop_start != peek )
  3548.       {
  3549.           if ( REG == GET_CODE ( linv ))
  3550.           {
  3551.           emit_insn_before ( 
  3552.                     gen_rtx ( SET, VOIDmode, analog,
  3553.                          add_expr ),
  3554.                     loop_start );
  3555.  
  3556.           emit_insn_before (
  3557.                     gen_rtx ( SET, VOIDmode, analog,
  3558.                          gen_rtx ( PLUS, Pmode, analog,
  3559.                               biv_increment )),
  3560.                     loop_start );
  3561.           }
  3562.           else
  3563.           {
  3564.           rtx tmp = gen_reg_rtx ( SImode );
  3565.           
  3566.           emit_insn_before (
  3567.                     gen_rtx ( SET, VOIDmode, tmp,
  3568.                          gen_rtx ( PLUS, Pmode,
  3569.                               biv_increment,
  3570.                               linv )),
  3571.                     loop_start );
  3572.                          
  3573.           emit_insn_before ( 
  3574.                     gen_rtx ( SET, VOIDmode, analog,
  3575.                          gen_rtx ( PLUS, Pmode,
  3576.                               biv, tmp )),
  3577.                     loop_start );
  3578.           }
  3579.       }
  3580.       else
  3581.       {
  3582.           emit_insn_before ( 
  3583.                 gen_rtx ( SET, VOIDmode, analog, add_expr ),
  3584.                 loop_start );
  3585.       }
  3586.       }
  3587.   }
  3588.  
  3589.   /* DO LOOPS: qualify and possibly convert this loop into a do loop.
  3590.    * to qualify a loop as a potential do loop:
  3591.    * (1) there must be only one conditional back branch.
  3592.    * (2) the cmp for (1) must be between a BIV and a loop invariant.
  3593.    * (3) let c be the increment stride of the biv. c must be constant
  3594.    * and c must be a power of two. 
  3595.    *
  3596.    * if the loop qualifies, a canonical equivalent of the looping mechanism
  3597.    * must be constructed: for ( i = a; i <= b; i += c ). If all of a, b, and
  3598.    * c are known constants, we can determine the loop count as:
  3599.    * _____________
  3600.    * | 1 + b - a |
  3601.    * | --------- |
  3602.    * |     c     |
  3603.    *
  3604.    * if not, we need to generate a string of insns which will compute the
  3605.    * loop count at runtime, and check for a zero or negative count. 
  3606.    *
  3607.    * we then need to pull the loop control to the top of the loop into 
  3608.    * a form that the code generator will recognize. We also need to eliminate
  3609.    * the BIV and the loop invariant of the comparison.
  3610.    */
  3611.   /* use the do ... while (0) construct so that a break is equivalent to
  3612.    * a rejection of the loop.
  3613.    */
  3614.   if ( TARGET_DO_LOOP_GENERATION )
  3615.   do
  3616.   {
  3617.       /* these four insns are identified when the loop is qualified.
  3618.        * they consist of the top of the loop label, the single back-branch,
  3619.        * the BIV increment, and the loop invariant/BIV compare insn.
  3620.        */
  3621.       rtx compare_insn, back_branch_insn, looping_label;
  3622.       
  3623.       /* these four rtx expressions are identified when the loop is qualified:
  3624.        * the loop_bound which the biv is compared against, the biv (duh),
  3625.        * the initial value of the biv ( as best we can determine - if it is
  3626.        * vaiable, it is null ), and the increment value of the biv. continue
  3627.        * relation is the rtx used as the decision maker in the back branch
  3628.        * insn.
  3629.        */
  3630.       rtx loop_bound, biv, biv_initial, biv_increment, continue_relation;
  3631.       
  3632.       /* these rtx are created within this section of code after (except
  3633.        * bypass_label) we have found the loop to be "DOable". loop_count
  3634.        * is a reg rtx which has the number of loop iterations computed into
  3635.        * it. bypass_label is jumped to if the loop is not to be executed at
  3636.        * all.
  3637.        */
  3638.       rtx loop_count, bypass_label;
  3639.       
  3640.       rtx tmp, tmp2;
  3641.       
  3642.       /* find the looping label (1st label in the loop, with no preceeding
  3643.        * insns).
  3644.        */
  3645.       tmp = loop_start;
  3646.       while ( tmp = NEXT_INSN ( tmp ), tmp && ( NOTE == GET_CODE ( tmp )));
  3647.       if (( ! tmp ) || ( CODE_LABEL != GET_CODE ( tmp )))
  3648.       {
  3649.       break;
  3650.       }
  3651.       looping_label = tmp;
  3652.  
  3653.       /* find the back branch insn. */
  3654.       tmp = loop_end;
  3655.       while ( tmp = PREV_INSN ( tmp ), tmp && ( NOTE == GET_CODE ( tmp )));
  3656.       if (( ! tmp ) || ( JUMP_INSN != GET_CODE ( tmp )) ||
  3657.       ( looping_label != get_bcond_label ( tmp )))
  3658.       {
  3659.       break;
  3660.       }
  3661.       back_branch_insn = tmp;
  3662.       continue_relation = XEXP ( SET_SRC ( PATTERN ( tmp )), 0 );
  3663.       
  3664.       /* scan down the loop and make sure that only one branch references 
  3665.        * the looping label. we need to make sure that there aren't any 
  3666.        * extra back-branches which would screw the possibility of using a
  3667.        * do. gee, it would be nice to have a control flow graph here ... 
  3668.        */
  3669.       for ( tmp = NEXT_INSN( looping_label );
  3670.        tmp && ( tmp != back_branch_insn );
  3671.        tmp = NEXT_INSN ( tmp ))
  3672.       {
  3673.       if ( JUMP_INSN == GET_CODE ( tmp ))
  3674.       {
  3675.           if (( PARALLEL == GET_CODE ( PATTERN ( tmp ))) &&
  3676.           ( CLOBBER == GET_CODE ( XVECEXP ( PATTERN ( tmp ),0,0))) &&
  3677.           ((( 3 == XVECLEN ( PATTERN ( tmp ), 0 )) &&
  3678.             ( USE == GET_CODE ( XVECEXP ( PATTERN ( tmp ),0,1 ))) &&
  3679.             ( SET == GET_CODE ( XVECEXP ( PATTERN ( tmp ),0,2 )))) ||
  3680.            (( 2 == XVECLEN ( PATTERN ( tmp ), 0 )) &&
  3681.             ( SET == GET_CODE ( XVECEXP ( PATTERN ( tmp ),0,1 ))))))
  3682.           {
  3683.           /* check for a "do" or "od" shape. these are ok. */
  3684.           ;
  3685.           }
  3686.           else if ( SET != GET_CODE ( PATTERN ( tmp )))
  3687.           {
  3688.           tmp = 0;
  3689.           /* code gen bug on sun4. */
  3690.           break;
  3691.           }
  3692.           else
  3693.           {
  3694.           switch ( GET_CODE ( SET_SRC ( PATTERN ( tmp ))))
  3695.           {
  3696.           case LABEL_REF:
  3697.               if ( SET_SRC ( PATTERN ( tmp )) == looping_label )
  3698.               {
  3699.               tmp = 0;
  3700.               }
  3701.               break;
  3702.           
  3703.           case IF_THEN_ELSE:
  3704.               tmp2 = get_bcond_label ( tmp );
  3705.               if (( ! tmp2 ) || ( tmp2 == looping_label ))
  3706.               {
  3707.               tmp = 0;
  3708.               }
  3709.               break;
  3710.           
  3711.           default:
  3712.               tmp = 0;
  3713.           }
  3714.           }
  3715.       }
  3716.       }
  3717.       if ( ! tmp )
  3718.       {
  3719.       break;
  3720.       }
  3721.  
  3722.       /* make sure that there are no jumps out of the loop. this function
  3723.        * also ensures that we won't nest do instructions too deeply by checking
  3724.        * the encountered depth against MAX_DO_LOOP_NESTING. 
  3725.        */
  3726.       if ( ! no_jumps_out_of_loop_p ( loop_start, loop_end ))
  3727.       {
  3728.       break;
  3729.       }
  3730.       
  3731.       /* find the compare or tst instruction before this conditional jump. */
  3732.       while ( tmp = PREV_INSN ( tmp ), tmp && ( NOTE == GET_CODE ( tmp )));
  3733.       if (( ! tmp ) || ( INSN != GET_CODE ( tmp )) || 
  3734.       ( SET != GET_CODE ( PATTERN ( tmp ))) || 
  3735.       ( cc0_rtx != SET_DEST ( PATTERN ( tmp ))))
  3736.       {
  3737.       break;
  3738.       }
  3739.       compare_insn = tmp;
  3740.       
  3741.       /* use the precomputed information provided by the strength-reduction
  3742.        * part of this pass: ensure that one of the operands of the cmp, or
  3743.        * that the operand to the tst is actually a biv.
  3744.        */
  3745.       if ( COMPARE == GET_CODE ( tmp2 = SET_SRC ( PATTERN ( tmp ))))
  3746.       {
  3747.       if (( REG == GET_CODE ( biv = XEXP ( tmp2, 0 ))) &&
  3748.           ( nregs > REGNO ( biv )) &&
  3749.           ( BASIC_INDUCT == induct_var[ REGNO ( biv ) ] ))
  3750.       {
  3751.           loop_bound = XEXP ( tmp2, 1 );
  3752.       }
  3753.       else if (( REG == GET_CODE ( biv = XEXP ( tmp2, 1 ))) &&
  3754.            ( nregs > REGNO ( biv )) &&
  3755.            ( BASIC_INDUCT == induct_var[ REGNO ( biv ) ] ))
  3756.       {
  3757.           loop_bound = XEXP ( tmp2, 0 );
  3758.       }
  3759.       else
  3760.       {
  3761.           break;
  3762.       }
  3763.       }
  3764.       else if ( REG == GET_CODE ( biv = SET_SRC ( PATTERN ( tmp ))))
  3765.       {
  3766.       if (( nregs > REGNO ( biv ) ) ||
  3767.           ( BASIC_INDUCT != induct_var[ REGNO ( biv ) ] ) ||
  3768.           ( 0 == class_struct[ REGNO ( biv ) ] ))
  3769.       {
  3770.           break;
  3771.       }
  3772.       loop_bound = const0_rtx;
  3773.       }
  3774.       else
  3775.       {
  3776.       break;
  3777.       }
  3778.       /* check to see if the biv meets a more stringent set of specs. */
  3779.  
  3780.       if ( ! biv_qualified_p ( biv, looping_label, back_branch_insn ))
  3781.       {
  3782.       break;
  3783.       }
  3784.       
  3785.       /* biv really is a biv. we've verified that with the existance
  3786.        * of induct_var for that regno. loop_bound may or may not be a valid
  3787.        * loop bound for us. we will try to determine whether or not loop bound
  3788.        * is or isn't loop invariant, and whether or not it is a constant.
  3789.        */
  3790.       loop_bound = find_best_equiv ( loop_bound, compare_insn, loop_start );
  3791.       if ( NULL == loop_bound )
  3792.       {
  3793.       /* the loop bound may not be invariant within the loop. */
  3794.       break;
  3795.       }
  3796.  
  3797.       /* attempt to find the initial values of the biv and (possibly) an
  3798.        * initial value for the loop bound.
  3799.        */
  3800.       tmp = loop_start;
  3801.       while ( tmp = PREV_INSN ( tmp ), ( tmp ) && ( PREV_INSN ( tmp )) &&
  3802.          ( CODE_LABEL != GET_CODE ( tmp )));
  3803.       
  3804.       biv_initial = ( tmp2 = find_best_equiv ( biv, loop_start, tmp )) ?
  3805.       tmp2 : biv;
  3806.       
  3807.       loop_bound = ( tmp2 = find_best_equiv ( loop_bound, loop_start, tmp )) ?
  3808.       tmp2 : loop_bound;
  3809.       
  3810.  
  3811.       /* sometimes a constant will get CSE'ed out of an increment, because
  3812.        * constants are, in general, expensive. we need to see whether the
  3813.        * biv inc/dec modifier is actually a constant.
  3814.        */
  3815.       biv_increment = class_struct[ REGNO ( biv ) ]->biv->add_val;
  3816.  
  3817.       if ( CONST_INT != GET_CODE ( biv_increment ))
  3818.       {
  3819.       if (( REG != GET_CODE ( biv_increment )) ||
  3820.           reg_set_between_p ( biv_increment, loop_start, loop_end ))
  3821.       {
  3822.           break;
  3823.       }
  3824.       biv_increment = find_best_equiv ( biv_increment, loop_start, tmp );
  3825.       
  3826.       if (( ! biv_increment ) ||
  3827.           ( CONST_INT != GET_CODE ( biv_increment )))
  3828.       {
  3829.           break;
  3830.       }
  3831.       }
  3832.       
  3833.       /* qualify the loop increment as a positive or negative power of
  3834.        * two. if not, the divide cost is too great a risk.
  3835.        */
  3836.       
  3837.       /* if biv_initial and biv are the same pseudo reg, we need to copy 
  3838.        * biv into a new pseudo register and call it biv_initial. this is
  3839.        * so that biv_inital remains constant down past the loop where it
  3840.        * may be used in the reconstruction of the induction variable.
  3841.        */
  3842.  
  3843.       if (( REG == GET_CODE ( biv_initial )) &&
  3844.       ( REGNO ( biv_initial ) == REGNO ( biv )))
  3845.       {
  3846.       biv_initial = gen_reg_rtx ( GET_MODE ( biv ));
  3847.       
  3848.       emit_insn_before ( gen_rtx ( SET, VOIDmode, biv_initial, biv ),
  3849.                 loop_start );
  3850.       }
  3851.  
  3852.       /* convert the loop into canonical form ( for ( i=a; i<=b; i +=c ))
  3853.        * if possible. emit instructions to compute (and possibly check) the
  3854.        * loop count into a new pseudo-reg. Also determine the (@loop end)
  3855.        * resulting value of the induction variable, and set it to that value
  3856.        * after the loop if the biv will be eliminated by the DO transformation
  3857.        * also emit nop bounded do target. we need nop bounding in order to
  3858.        * have nested do loops and conditionals within do loops.
  3859.        */
  3860.       
  3861.       emit_label_after ( bypass_label = gen_label_rtx ( ), loop_end );
  3862.       emit_insn_before ( const0_rtx, bypass_label );
  3863.       emit_insn_after ( const0_rtx, bypass_label );
  3864.       
  3865.       if ( NULL == ( loop_count = 
  3866.             compute_loop_count ( loop_start, tmp, bypass_label, 
  3867.                     biv_initial, continue_relation,
  3868.                     loop_bound, biv_increment )))
  3869.       {
  3870.       continue;
  3871.       }
  3872.       
  3873.       /* create a burly-ass ( parallel [ ... ] ) JUMP_INSN. this should match
  3874.        * the "do" shape. we also need to make a bogus back-branch so that any
  3875.        * jump optimizer will see that there is an inherent back branch in
  3876.        * the do-loop label. this back branch will match some funky-ass 
  3877.        * ( parallel [ ... ] ) JUMP_INSN.
  3878.        */
  3879.  
  3880.       /* in the case of a single iteration loop, no iteration control is
  3881.        * needed.
  3882.        */
  3883.       if (( CONST_INT != GET_CODE ( loop_count )) ||
  3884.       ( 1 != INTVAL ( loop_count )))
  3885.       {
  3886.       /* an aside: putting the do-shape before the NOTE_INSN_LOOP_BEG
  3887.        * affects the depth counter in flow.c. This ensures that when
  3888.        * a "do d5,L111" instruction is issued, d5's reg_n_ref won't be
  3889.        * counted as in the loop.
  3890.        */
  3891.       emit_jump_insn_before ( 
  3892.         gen_rtx ( PARALLEL, VOIDmode,
  3893.           gen_rtvec ( 3,
  3894.         gen_rtx ( CLOBBER, VOIDmode, cc0_rtx ),
  3895.         gen_rtx ( USE, VOIDmode, loop_count ),
  3896.         gen_rtx ( SET, VOIDmode, pc_rtx,
  3897.           gen_rtx ( IF_THEN_ELSE, VOIDmode,
  3898.             gen_rtx ( EQ, SImode, cc0_rtx, const0_rtx ),
  3899.             gen_rtx ( LABEL_REF, Pmode, bypass_label ),
  3900.             pc_rtx )))), loop_start );
  3901.       
  3902.       emit_jump_insn_before ( 
  3903.         gen_rtx ( PARALLEL, VOIDmode,
  3904.           gen_rtvec ( 2, 
  3905.         gen_rtx ( CLOBBER, VOIDmode, cc0_rtx ),
  3906.         gen_rtx ( SET, VOIDmode, pc_rtx, 
  3907.           gen_rtx ( LABEL_REF, Pmode, looping_label )))), loop_end );
  3908.       }
  3909.  
  3910.       /* eliminate the old compare and back branch instructions
  3911.        * by replacing them with NOTEs. This may open up opportunities for
  3912.        * data-flow driven dead code elimination as well.
  3913.        */
  3914.  
  3915.       PUT_CODE ( compare_insn, NOTE );
  3916.       NOTE_LINE_NUMBER ( compare_insn ) = NOTE_INSN_DELETED;
  3917.       PUT_CODE ( back_branch_insn, NOTE );
  3918.       NOTE_LINE_NUMBER ( back_branch_insn ) = NOTE_INSN_DELETED;
  3919.       
  3920.       /* decide whether or not to jam out a ( set ... ) which will set
  3921.        * the induction variable to the loop termination value. If the
  3922.        * induction variable is being used within the loop, don't. Otherwise
  3923.        * set the iv after the loop so that the iv ( set ... ) within the
  3924.        * loop might be blown out as dead code.
  3925.        */
  3926.  
  3927.       if (( ! reg_really_used_between_p ( biv, loop_start, 
  3928.                   class_struct[ REGNO ( biv ) ]->biv->insn ))
  3929.       &&
  3930.       ( ! reg_really_used_between_p ( biv, 
  3931.                   class_struct[ REGNO ( biv ) ]->biv->insn,
  3932.                   loop_end )))
  3933.       {
  3934.       if ( CONST_INT == GET_CODE ( loop_count ))
  3935.       {
  3936.           /* we have a const loop count <=> a,b,c are consts. */
  3937.  
  3938.           emit_insn_after ( 
  3939.                    gen_rtx ( SET, VOIDmode, biv,
  3940.                     gen_rtx ( CONST_INT, VOIDmode,
  3941.                          INTVAL ( biv_initial ) + 
  3942.                          INTVAL ( biv_increment ) * 
  3943.                          INTVAL ( loop_count ))),
  3944.                    bypass_label );
  3945.       }
  3946.       else /* REG == GET_CODE ( loop_count ) */
  3947.       {
  3948.           rtx biv_initial_reg, mult_reg = gen_reg_rtx ( SImode );
  3949.           
  3950.           
  3951.           biv_initial_reg = ( REG == GET_CODE ( biv_initial )) ?
  3952.                  biv_initial :
  3953.                  gen_reg_rtx ( GET_MODE ( biv ));
  3954.           
  3955.           emit_insn_after ( gen_rtx ( SET, VOIDmode, biv,
  3956.                      gen_rtx ( PLUS, GET_MODE ( biv ),
  3957.                           biv_initial_reg,
  3958.                           mult_reg )), 
  3959.                    bypass_label );
  3960.           
  3961.           emit_insn_after ( gen_rtx ( SET, VOIDmode, mult_reg,
  3962.                      gen_rtx ( MULT, SImode,
  3963.                           biv_increment,
  3964.                           loop_count )), 
  3965.                    bypass_label );
  3966.  
  3967.           if ( biv_initial_reg != biv_initial )
  3968.           {
  3969.           emit_insn_after ( gen_rtx ( SET, VOIDmode, biv_initial_reg,
  3970.                          biv_initial ), bypass_label );
  3971.           }
  3972.       }
  3973.       }
  3974.   } while ( 0 );
  3975. #endif
  3976. }
  3977.  
  3978. /* Nonzero if register REG appears somewhere within IN, except in
  3979.    subexpressions EQ to EXPR.  This is a modification of reg_mentioned_p.  */
  3980.  
  3981. int
  3982. only_reg_use_p (reg, expr, in)
  3983.      register rtx reg, expr, in;
  3984. {
  3985.   register char *fmt;
  3986.   register int i;
  3987.   register enum rtx_code code;
  3988.  
  3989.   if (in == 0)
  3990.     return 0;
  3991.  
  3992.   if (reg == expr)
  3993.     return 0;
  3994.  
  3995.   if (reg == in)
  3996.     return 1;
  3997.  
  3998.   code = GET_CODE (in);
  3999.  
  4000.   switch (code)
  4001.     {
  4002.       /* Compare registers by number.  */
  4003.     case REG:
  4004.       return GET_CODE (reg) == REG && REGNO (in) == REGNO (reg);
  4005.  
  4006.       /* These codes have no constituent expressions
  4007.      and are unique.  */
  4008.     case CC0:
  4009.     case PC:
  4010.     case CONST_INT:
  4011.     case CONST_DOUBLE:
  4012.     case SYMBOL_REF:
  4013.     case CODE_LABEL:
  4014.       return 0;
  4015.     }
  4016.  
  4017.   fmt = GET_RTX_FORMAT (code);
  4018.  
  4019.   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
  4020.     {
  4021.       if (fmt[i] == 'E')
  4022.     {
  4023.       register int j;
  4024.       for (j = XVECLEN (in, i) - 1; j >= 0; j--)
  4025.         if (only_reg_use_p (reg, expr, XVECEXP (in, i, j)))
  4026.           return 1;
  4027.     }
  4028.       else if (fmt[i] == 'e'
  4029.            && only_reg_use_p (reg, expr, XEXP (in, i)))
  4030.     return 1;
  4031.     }
  4032.   return 0;
  4033. }
  4034.  
  4035. /* Scan X for memory refs and check each memory address
  4036.    as a possible giv.  INSN is the insn whose pattern X comes from.
  4037.    MAYBE_NEVER is 1 if the loop might execute INSN zero times.  */
  4038.  
  4039. static void
  4040. find_mem_givs (x, insn, maybe_never, loop_end)
  4041.      rtx x;
  4042.      rtx insn;
  4043.      int maybe_never;
  4044.      rtx loop_end;
  4045. {
  4046.   register int i, j;
  4047.   register enum rtx_code code;
  4048.   register char *fmt;
  4049.  
  4050.   if (x == 0)
  4051.     return;
  4052.  
  4053.   code = GET_CODE (x);
  4054.   switch (code)
  4055.     {
  4056.     case REG:
  4057.     case CONST_INT:
  4058.     case CONST:
  4059.     case CONST_DOUBLE:
  4060.     case SYMBOL_REF:
  4061.     case LABEL_REF:
  4062.     case PC:
  4063.     case CC0:
  4064.     case ADDR_VEC:
  4065.     case ADDR_DIFF_VEC:
  4066.     case USE:
  4067.     case CLOBBER:
  4068.       return;
  4069.  
  4070.     case MEM:
  4071.       {
  4072.     int src_regno;
  4073.     rtx add_val;
  4074.     rtx mult_val;
  4075.     int benefit;
  4076.     struct induction *forces = 0;
  4077.     struct induction *forces2 = 0;
  4078.  
  4079.     benefit = general_induction_var (XEXP (x, 0),
  4080.                      &src_regno, &add_val, &mult_val,
  4081.                      &forces, &forces2);
  4082.     if (benefit > 0)
  4083.       {
  4084.         /* Found one; record it.  */
  4085.         struct induction *v =
  4086.           (struct induction *) oballoc (sizeof (struct induction));
  4087.  
  4088.         record_giv (v, insn, src_regno, 0, mult_val, add_val, benefit,
  4089.             forces, forces2, DEST_ADDR, maybe_never, &XEXP (x, 0),
  4090.             loop_end);
  4091.       }
  4092.     return;
  4093.       }
  4094.     }
  4095.  
  4096.   /* Recursively scan the subexpressions for other mem refs.  */
  4097.  
  4098.   fmt = GET_RTX_FORMAT (code);
  4099.   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
  4100.     if (fmt[i] == 'e')
  4101.       find_mem_givs (XEXP (x, i), insn, maybe_never, loop_end);
  4102.     else if (fmt[i] == 'E')
  4103.       for (j = 0; j < XVECLEN (x, i); j++)
  4104.     find_mem_givs (XVECEXP (x, i, j), insn, maybe_never, loop_end);
  4105. }
  4106.  
  4107. /* Fill in the data about one giv.
  4108.    V is the `struct induction' in which we record the giv.  (It is
  4109.    allocated by the caller, with alloca.)
  4110.    INSN is the insn that sets it.
  4111.    BENEFIT estimates the savings from deleting this insn.
  4112.    TYPE is DEST_REG or DEST_ADDR; it says whether the giv is computed
  4113.    into a register or is used as a memory address.
  4114.  
  4115.    SRC_REGNO is the biv reg number which the giv is computed from.
  4116.    DEST_REGNO is the giv's reg number (if the giv is stored in a reg).
  4117.    MULT_VAL and ADD_VAL are the coefficients used to compute the giv.
  4118.    FORCES and FORCES2, if nonzero, are other `struct induction's for
  4119.    other givs which are used to compute this giv indirectly.
  4120.    LOCATION points to the place where this giv's value appears in INSN.  */
  4121.  
  4122. static void
  4123. record_giv (v, insn, src_regno, dest_regno, mult_val, add_val, benefit,
  4124.         forces, forces2, type, maybe_never, location, loop_end)
  4125.      struct induction *v;
  4126.      rtx insn;
  4127.      int src_regno, dest_regno;
  4128.      rtx mult_val, add_val;
  4129.      int benefit;
  4130.      struct induction *forces, *forces2;
  4131.      enum g_types type;
  4132.      int maybe_never;
  4133.      rtx *location;
  4134.      rtx loop_end;
  4135. {
  4136.   struct induction *b;
  4137.   struct iv_class *bl;
  4138.  
  4139.   v->insn = insn;
  4140.   v->src_regno = src_regno;
  4141.   v->giv_type = type;
  4142.   v->dest_regno = dest_regno;
  4143.   v->mult_val = mult_val;
  4144.   v->add_val = add_val;
  4145.   v->benefit = benefit;
  4146.   v->location = location;
  4147.  
  4148.   if (type == DEST_ADDR)
  4149.     {
  4150.       v->mode = GET_MODE (*location);
  4151.       v->consec = 0;
  4152.       v->lifetime = 1;
  4153.       v->times_used = 1;
  4154.     }
  4155.   else /* type == DEST_REG */
  4156.     {
  4157.       v->mode = GET_MODE (SET_DEST (PATTERN (insn)));
  4158.       v->consec = n_times_set[dest_regno] - 1;
  4159.       v->lifetime = (uid_luid[regno_last_uid[dest_regno]]
  4160.              - uid_luid[regno_first_uid[dest_regno]]);
  4161.       v->times_used = n_times_used[dest_regno];
  4162.     }
  4163.  
  4164.   v->same = 0;
  4165.   v->forces = 0;
  4166.   v->forces2 = 0;
  4167.   v->ignore = 0;
  4168.   v->new_reg = 0;
  4169.  
  4170.   /* Mark giv as forced if it is only used to compute another giv.  */
  4171.  
  4172.   /* This check is not sufficient as INSN may have been moved giving
  4173.      it a new uid, so make another check by calculating lifetimes.
  4174.      This is overconservative but seems to be correct.  */
  4175.  
  4176.   if (forces)
  4177.     {
  4178.       v->benefit += forces->benefit;
  4179.       if ((regno_last_uid[forces->dest_regno] == INSN_UID (insn)
  4180.        ||
  4181.        ((uid_luid[regno_last_uid[forces->dest_regno]]
  4182.          - uid_luid[regno_first_uid[forces->dest_regno]])
  4183.         == (INSN_LUID (insn) - INSN_LUID (forces->insn))))
  4184.       && !reg_used_between_p (SET_DEST (PATTERN (forces->insn)),
  4185.                   forces->insn, insn))
  4186.      {
  4187.       v->forces = forces;
  4188.       forces->ignore = 1;
  4189.      }
  4190.     }
  4191.  
  4192.   if (forces2)
  4193.     {
  4194.       v->benefit += forces2->benefit;
  4195.       if ((regno_last_uid[forces2->dest_regno] == INSN_UID (insn)
  4196.        ||
  4197.        ((uid_luid[regno_last_uid[forces2->dest_regno]]
  4198.          - uid_luid[regno_first_uid[forces2->dest_regno]])
  4199.         == (INSN_LUID (insn) - INSN_LUID (forces2->insn))))
  4200.       && !reg_used_between_p (SET_DEST (PATTERN (forces2->insn)),
  4201.                   forces2->insn, insn))
  4202.      {
  4203.       if (v->forces)
  4204.         v->forces2 = forces2;
  4205.       else
  4206.         v->forces = forces2;
  4207.       forces2->ignore = 1;
  4208.     }
  4209.     }
  4210.  
  4211.   if (type == DEST_REG)
  4212.     {
  4213.       induct_var[dest_regno] = GENERAL_INDUCT;
  4214.       induct_struct[dest_regno] = v;
  4215.     }
  4216.  
  4217.   /* Add the giv to the class of givs computed from one biv.  */
  4218.  
  4219.   bl = class_struct[src_regno];
  4220.   if (bl)
  4221.     {
  4222.       v->family = bl->giv;
  4223.       bl->giv = v;
  4224.       /* Don't count DEST_ADDR.  This is supposed to count the number of
  4225.      insns that calculate givs.  */
  4226.       if (type == DEST_REG)
  4227.     bl->giv_count++;
  4228.       bl->total_benefit += benefit;
  4229.     }
  4230.   else
  4231.     /* Fatal error, biv missing for this giv?  */
  4232.     abort ();
  4233.  
  4234.   if (type == DEST_ADDR)
  4235.     v->replaceable = 1;
  4236.   else
  4237.     {
  4238.       /* The giv can be replaced outright by the reduced register if
  4239.       - the insn that sets the giv is always executed on any iteration
  4240.        on which the giv is used at all
  4241.        (there are two ways to deduce this:
  4242.         either the insn is executed on every iteration,
  4243.         or all uses follow that insn in the same basic block),
  4244.       - the giv is not used before the insn that sets it,
  4245.          i.e. no definition outside loop reaches into loop
  4246.      - no assignments to the biv occur during the giv's lifetime.  */
  4247.  
  4248.       /* Is this right?  Don't we need to make sure the giv is not used
  4249.      outside the loop.  Someday we will know where all the loop exits
  4250.      are so we can do better, but until then....
  4251.      March 18, 1989 -- self@bayes.arc.nasa.gov */
  4252.  
  4253.       if (regno_first_uid[dest_regno] == INSN_UID (insn)
  4254.       /* Previous line always fails if INSN was moved by loop opt.  */
  4255.       && uid_luid[regno_last_uid[dest_regno]] < INSN_LUID (loop_end)
  4256.       && (!maybe_never || last_use_this_basic_block (dest_regno, insn)))
  4257.      {
  4258.       v->replaceable = 1;
  4259.       for (b = bl->biv; b; b = b->family)
  4260.         {
  4261.           if ((uid_luid[INSN_UID (b->insn)] >= uid_luid[regno_first_uid[dest_regno]])
  4262.           &&
  4263.           (uid_luid[INSN_UID (b->insn)]
  4264.            <= uid_luid[regno_last_uid[dest_regno]]))
  4265.         {
  4266.           v->replaceable = 0;
  4267.           break;
  4268.          }
  4269.         }
  4270.     }
  4271.       else
  4272.      v->replaceable = 0;
  4273.     }
  4274.  
  4275.   if (loop_dump_stream)
  4276.     {
  4277.       if (type == DEST_REG)
  4278.      fprintf (loop_dump_stream, "Insn %d: giv reg %d",
  4279.          INSN_UID (insn), dest_regno);
  4280.       else
  4281.      fprintf (loop_dump_stream, "Insn %d: dest address",
  4282.           INSN_UID (insn));
  4283.  
  4284.       fprintf (loop_dump_stream, " src reg %d benefit %d",
  4285.            src_regno, v->benefit);
  4286.       fprintf (loop_dump_stream, " used %d lifetime %d",
  4287.            v->times_used, v->lifetime);
  4288.  
  4289.       if (v->replaceable)
  4290.      fprintf (loop_dump_stream, " replaceable");
  4291.  
  4292.       if (GET_CODE (mult_val) == CONST_INT)
  4293.     fprintf (loop_dump_stream, " mult %d",
  4294.           INTVAL (mult_val));
  4295.       else
  4296.     {
  4297.       fprintf (loop_dump_stream, " mult ");
  4298.       print_rtl (loop_dump_stream, mult_val);
  4299.     }
  4300.  
  4301.       if (GET_CODE (add_val) == CONST_INT)
  4302.     fprintf (loop_dump_stream, " add %d",
  4303.          INTVAL (add_val));
  4304.       else
  4305.     {
  4306.       fprintf (loop_dump_stream, " add ");
  4307.       print_rtl (loop_dump_stream, add_val);
  4308.     }
  4309.     }
  4310.  
  4311.   if (loop_dump_stream && v->forces)
  4312.     fprintf (loop_dump_stream, " forces insn %d", INSN_UID (v->forces->insn));
  4313.   if (loop_dump_stream && v->forces2)
  4314.     fprintf (loop_dump_stream, " forces insn %d", INSN_UID (v->forces2->insn));
  4315.   if (loop_dump_stream && v->consec)
  4316.     fprintf (loop_dump_stream, " consec %d", v->consec);
  4317.   if (loop_dump_stream)
  4318.     fprintf (loop_dump_stream, "\n");
  4319. }
  4320.  
  4321. /* Delete the insns forced by the insn described by V.
  4322.    If THIS_TOO is nonzero, delete that insn itself as well.  */
  4323.  
  4324. static void
  4325. delete_insn_forces (v, this_too)
  4326.      struct induction *v;
  4327.      int this_too;
  4328. {
  4329.   rtx x, p;
  4330.   int count;
  4331.   rtx insn;
  4332.  
  4333.   if (this_too)
  4334.     {
  4335.       insn = v->insn;
  4336.       for (count = v->consec; count >= 0; count--)
  4337.     {
  4338.       /* If first insn of libcall sequence, skip to end.  */
  4339.       /* Do this at start of loop, since p is guaranteed to
  4340.          be an insn here.  */
  4341.       if (x = find_reg_note (insn, REG_LIBCALL, 0))
  4342.         insn = XEXP (x, 0);
  4343.  
  4344.       if (x = find_reg_note (insn, REG_RETVAL, 0))
  4345.         {
  4346.           /* This is a library call; delete all insns backward until get to
  4347.          first insn in this group.  */
  4348.           rtx first = XEXP (x, 0);
  4349.           for (p = insn; p != first; p = PREV_INSN (p))
  4350.         delete_insn (p);
  4351.           /* Delete first insn also.  */
  4352.           delete_insn (p);
  4353.         }
  4354.       else
  4355.         delete_insn (insn);
  4356.  
  4357.       do insn = NEXT_INSN (insn);
  4358.       while (GET_CODE (insn) == NOTE);
  4359.     }
  4360.     }
  4361.  
  4362.   if (v->forces)
  4363.     delete_insn_forces (v->forces, 1);
  4364.   if (v->forces2)
  4365.     delete_insn_forces (v->forces2, 1);
  4366. }
  4367.  
  4368. /* Check whether an insn is an increment legitimate for a basic induction var.
  4369.    X is the source of the insn.
  4370.    DEST_REG is the putative biv, also the destination of the insn.
  4371.    We accept patterns of these forms:
  4372.      REG = REG + INVARIANT
  4373.      REG = INVARIANT + REG
  4374.      REG = REG - CONSTANT
  4375.  
  4376.    If X is suitable, we return 1,
  4377.    and store the factor multiplying REF in X into *MULT_VAL
  4378.    and the additive term into *INC_VAL.
  4379.    Otherwise we return 0.  */
  4380.  
  4381. static int
  4382. basic_induction_var (x, dest_regno, inc_val, mult_val)
  4383.      register rtx x;
  4384.      int dest_regno;
  4385.      rtx *inc_val;
  4386.      rtx *mult_val;
  4387. {
  4388.   register enum rtx_code code;
  4389.   rtx arg;
  4390.  
  4391.   if (x == 0)
  4392.     return 0;
  4393.   code = GET_CODE (x);
  4394.   switch (code)
  4395.     {
  4396.     case PLUS:
  4397.       if (GET_CODE (XEXP (x, 0)) == REG
  4398.       && REGNO (XEXP (x, 0)) == dest_regno)
  4399.      arg = XEXP (x, 1);
  4400.       else if (GET_CODE (XEXP (x, 1)) == REG
  4401.            && REGNO (XEXP (x, 1)) == dest_regno)
  4402.     arg = XEXP (x, 0);
  4403.       else
  4404.      return 0;
  4405.  
  4406.       if (invariant_p (arg) == 1)
  4407.     *inc_val = arg;
  4408.       else
  4409.     return 0;
  4410.  
  4411.       *mult_val = const1_rtx;
  4412.       return 1;
  4413.  
  4414.     case MINUS:
  4415.       if (GET_CODE (XEXP (x, 0)) == REG
  4416.        && REGNO (XEXP (x, 0)) == dest_regno
  4417.        && GET_CODE (XEXP (x, 1)) == CONST_INT)
  4418.      *inc_val = gen_rtx (CONST_INT, VOIDmode,
  4419.                 - INTVAL (XEXP (x, 1)));
  4420.       else
  4421.      return 0;
  4422.       *mult_val = const1_rtx;
  4423.       return 1;
  4424.  
  4425.       /* Can accept constant setting of biv only when inside inner most loop.
  4426.        Otherwise, a biv of an inner loop may be incorrectly recognized
  4427.      as a biv of the outer loop,
  4428.      causing code to be moved INTO the inner loop.  */
  4429.     case REG:
  4430.       if (!invariant_p (x))
  4431.     return 0;
  4432.     case CONST_INT:
  4433.     case SYMBOL_REF:
  4434.     case CONST:
  4435.       if (loops_enclosed == 1)
  4436.      {
  4437.       *inc_val = x;
  4438.        *mult_val = const0_rtx;
  4439.        return 1;
  4440.      }
  4441.       else
  4442.      return 0;
  4443.  
  4444.     default:
  4445.       return 0;
  4446.     }
  4447. }
  4448.  
  4449. /* A general induction variable (giv) is any quantity that is a linear function
  4450.    of a basic induction variable, i.e. giv = biv * mult_val + add_val.
  4451.    The coefficients can be any loop invariant quantity.
  4452.    A giv need not be computed directly from the biv;
  4453.    it can be computed by way of other givs.  */
  4454.  
  4455. /* Determine whether X computes a giv.
  4456.    If it does, return a nonzero value
  4457.      which is the benefit from eliminating the computation of X;
  4458.    set *SRC_REGNO to the register number of the biv that it is computed from;
  4459.    set *ADD_VAL and *MULT_VAL to the coefficients,
  4460.      such that the value of X is biv * mult + add;
  4461.    set forces (and forces2) to identify any other givs that are used
  4462.      solely to compute this one.  */
  4463.  
  4464. /* This routine recognizes four types of patterns that generate givs:
  4465.    - giv = biv op invariant             v = 0,    g = 0
  4466.    - giv1 = giv2 op invariant           v = 0,    g = giv2
  4467.        where giv1 and giv2 are functions of the same biv
  4468.    - giv1 = biv op giv2                 v = giv2, g = 0
  4469.        where giv2 is a function of biv
  4470.    - giv1 = giv2 op giv3                v = giv3, g = giv2
  4471.        where giv2 and giv3 are functions of the save biv  */
  4472.  
  4473. static int
  4474. general_induction_var (x, src_regno, add_val, mult_val, forces, forces2)
  4475.      rtx x;
  4476.      int *src_regno;
  4477.      rtx *add_val;
  4478.      rtx *mult_val;
  4479.      struct induction **forces;
  4480.      struct induction **forces2;
  4481. {
  4482.   register enum rtx_code code;
  4483.   rtx arg;
  4484.   struct induction *g = 0;
  4485.   struct induction *v = 0;
  4486.   int subexp = 0;
  4487.   int tem;
  4488.  
  4489.   if (x == 0)
  4490.     return 0;
  4491.  
  4492.   code = GET_CODE (x);
  4493.   switch (code)
  4494.     {
  4495.     case NEG:
  4496.       /* This can generate givs also, but it is not handled.  */
  4497.       return 0;
  4498.  
  4499.     case MULT:
  4500.     case UMULT:
  4501.       /* Reject widening multiply in version 1.
  4502.      That is safer than trying to handle it.  */
  4503.       {
  4504.     enum machine_mode m0 = GET_MODE (XEXP (x, 0));
  4505.     enum machine_mode m1 = GET_MODE (XEXP (x, 1));
  4506.     if (m0 != VOIDmode && m0 != GET_MODE (x))
  4507.       return 0;
  4508.     if (m1 != VOIDmode && m1 != GET_MODE (x))
  4509.       return 0;
  4510.       }
  4511.     case PLUS:
  4512.     case MINUS:
  4513.       /* Result is linear in both operands.  */
  4514.       /* Determine which operand is the biv, and put the other in ARG.  */
  4515.       if (GET_CODE (XEXP (x, 0)) == REG
  4516.       && induct_var[REGNO (XEXP (x, 0))] == BASIC_INDUCT)
  4517.     {
  4518.       *src_regno = REGNO (XEXP (x, 0));
  4519.       arg = XEXP (x, 1);
  4520.  
  4521.     }
  4522.       else if (GET_CODE (XEXP (x, 1)) == REG
  4523.            && induct_var[REGNO (XEXP (x, 1))] == BASIC_INDUCT)
  4524.     {
  4525.       *src_regno = REGNO (XEXP (x, 1));
  4526.       arg = XEXP (x, 0);
  4527.  
  4528.     }
  4529.       /* Check for an rtl subexpression that is a giv.  Memory address
  4530.      givs often look like (plus (reg) (mult (biv) (const))).  */
  4531.       /* Do this before checking for a giv operand, as this function will
  4532.      fail if this special operand is not recognized.  */
  4533. #ifndef DONT_REDUCE_ADDR
  4534.       else if (tem = general_induction_var (XEXP (x, 1), src_regno,
  4535.                         add_val, mult_val,
  4536.                         forces, forces2)
  4537.            && code != MINUS)
  4538.     {
  4539.       /* Set subexp true so that this can be handled a little
  4540.          differently from the normal case of g set.  */
  4541.       /* Note that SRC_REGNO is already set.  */
  4542.       subexp = TRUE;
  4543.       g = (struct induction *) alloca (sizeof (struct induction));
  4544.       g->mult_val = *mult_val;
  4545.       g->add_val = *add_val;
  4546.       /* Fake out the test below.  */
  4547.       g->replaceable = 1;
  4548.       /* Count this multiply as a shift, since that's what it
  4549.          really will do.  */
  4550.       if (tem == MULT_BENEFIT)
  4551.         g->benefit = SHIFT_BENEFIT;
  4552.       else
  4553.         g->benefit = tem;
  4554.       arg = XEXP (x, 0);
  4555.     }
  4556.       else if (tem = general_induction_var (XEXP (x, 0), src_regno,
  4557.                         add_val, mult_val,
  4558.                         forces, forces2))
  4559.     {
  4560.       /* Set subexp true so that this can be handled a little
  4561.          differently from the normal case of g set.  */
  4562.       /* Note that SRC_REGNO is already set.  */
  4563.       subexp = TRUE;
  4564.       g = (struct induction *) alloca (sizeof (struct induction));
  4565.       g->mult_val = *mult_val;
  4566.       g->add_val = *add_val;
  4567.       /* Fake out the test below.  */
  4568.       g->replaceable = 1;
  4569.       /* Count this multiply as a shift, since that's what it
  4570.          really will do.  */
  4571.       if (tem == MULT_BENEFIT)
  4572.         g->benefit = SHIFT_BENEFIT;
  4573.       else
  4574.         g->benefit = tem;
  4575.       arg = XEXP (x, 1);
  4576.     }
  4577. #endif
  4578.       /* Also allow general induction variables.
  4579.      Could have a mult followed by an add (i.e. an address calculation),
  4580.      thereby generating two related general induction variables
  4581.      of which only the second is actually used.  */
  4582.       /* Do this after checking both args for basic induction variables.  */
  4583.       else if (GET_CODE (XEXP (x, 0)) == REG
  4584.            && induct_var[REGNO (XEXP (x, 0))] == GENERAL_INDUCT)
  4585.     {
  4586.       g = induct_struct[REGNO (XEXP (x, 0))];
  4587.       *src_regno = g->src_regno;
  4588.       arg = XEXP (x, 1);
  4589.     }
  4590.       else if (GET_CODE (XEXP (x, 1)) == REG
  4591.            && induct_var[REGNO (XEXP (x, 1))] == GENERAL_INDUCT
  4592.            && code != MINUS)
  4593.     {
  4594.       g = induct_struct[REGNO (XEXP (x, 1))];
  4595.       *src_regno = g->src_regno;
  4596.       arg = XEXP (x, 0);
  4597.     }
  4598.       else
  4599.     return 0;
  4600.  
  4601.       /* Overall form of expression looks good.  */
  4602.       break;
  4603.  
  4604.       /* Could handle these also.  */
  4605.     case DIV:
  4606.     case UDIV:
  4607.       /* For a 68020 could handle these? */
  4608.     case LSHIFT:
  4609.     case ASHIFT:
  4610.     case ASHIFTRT:
  4611.     case LSHIFTRT:
  4612.       /* These operations are linear only in first operand.
  4613.      Check for a biv or giv there; if found, put other operand in ARG.  */
  4614.       if (GET_CODE (XEXP (x, 0)) == REG
  4615.       && induct_var[REGNO (XEXP (x, 0))] == BASIC_INDUCT)
  4616.     {
  4617.       *src_regno = REGNO (XEXP (x, 0));
  4618.       arg = XEXP (x, 1);
  4619.     }
  4620.       /* Also allow general induction variable.  */
  4621.       else if (GET_CODE (XEXP (x, 0)) == REG
  4622.            && induct_var[REGNO (XEXP (x, 0))] == GENERAL_INDUCT)
  4623.     {
  4624.       g = induct_struct[REGNO (XEXP (x, 0))];
  4625.       *src_regno = g->src_regno;
  4626.       arg = XEXP (x, 1);
  4627.     }
  4628.       else
  4629.     return 0;
  4630.  
  4631.       /* Overall form of expression looks good.  */
  4632.       break;
  4633.  
  4634.     default:
  4635.       return 0;
  4636.     }
  4637.  
  4638.   /* ARG is the operand that is NOT a biv or giv.
  4639.      Test it for superficial validity.  */
  4640.  
  4641.   /* This is just a special case of invariant values,
  4642.      it is not really needed, but it's a shortcut.  */
  4643.   if (GET_CODE (arg) == CONST_INT)
  4644.     ;
  4645.  
  4646.   /* Depends on previous general induction variable, which has
  4647.      the same basic induction variable */
  4648.   /* This code detects mults that have been generated as shift and add.  */
  4649.   else if (GET_CODE (arg) == REG
  4650.        && induct_var[REGNO (arg)] == GENERAL_INDUCT
  4651.        && induct_struct[REGNO (arg)]->src_regno == *src_regno)
  4652.     {
  4653.       v = induct_struct[REGNO (arg)];
  4654.       /* Dependence indicated by forces, sort of kludgey.  */
  4655.     }
  4656.  
  4657.   /* Invariant expression, could be a constant-valued register. */
  4658.   else if (invariant_p (arg) == 1)
  4659.     ;
  4660.  
  4661.   /* Failure */
  4662.   else
  4663.     return 0;
  4664.     
  4665.   /* Until we can do the correct thing, suppress use of nonreplaceable givs
  4666.      as sources for other givs.  */
  4667.   if ((g && ! g->replaceable)
  4668.       || (v && ! v->replaceable))
  4669.     return 0;
  4670.  
  4671.   /* Now we know looks like a giv; extract the coefficients.
  4672.      We can still fail if the coefficients are not what we can handle.  */
  4673.  
  4674.   /* Only succeed if result mult_val and add_val are only one level of rtl,
  4675.      for example, (NEG:SI (REG:SI 34)) is not accepted.
  4676.      This mainly causes problems with the MINUS code.  */
  4677.  
  4678.   switch (code)
  4679.     {
  4680.     case PLUS:
  4681.       if (v && g)
  4682.     {
  4683.       if (GET_CODE (g->mult_val) == CONST_INT)
  4684.         {
  4685.           if (g->mult_val == const0_rtx)
  4686.         *mult_val = v->mult_val;
  4687.           else if (GET_CODE (v->mult_val) == CONST_INT)
  4688.         *mult_val = gen_rtx (CONST_INT, VOIDmode,
  4689.                        INTVAL (g->mult_val)
  4690.                        + INTVAL (v->mult_val));
  4691.           else
  4692.         return 0;
  4693.         }
  4694.       else if (v->mult_val == const0_rtx)
  4695.         *mult_val = g->mult_val;
  4696.       else
  4697.         return 0;
  4698.  
  4699.       if (GET_CODE (g->add_val) == CONST_INT)
  4700.         {
  4701.           if (g->add_val == const0_rtx)
  4702.         *add_val = v->add_val;
  4703.           else if (GET_CODE (v->add_val) == CONST_INT)
  4704.         *add_val = gen_rtx (CONST_INT, VOIDmode,
  4705.                        INTVAL (g->add_val)
  4706.                        + INTVAL (v->add_val));
  4707.           else
  4708.         return 0;
  4709.         }
  4710.       else if (v->add_val == const0_rtx)
  4711.         *add_val = g->add_val;
  4712.       else
  4713.         return 0;
  4714.  
  4715.       if (subexp)
  4716.         {
  4717.           /* g deleted when return, can't return pointer to it */
  4718.           if (*forces2 == 0)
  4719.         *forces2 = v;
  4720.           return ADD_BENEFIT + g->benefit;
  4721.         }
  4722.       else
  4723.         {
  4724.           *forces = g;
  4725.           *forces2 = v;
  4726.           return ADD_BENEFIT;
  4727.         }
  4728.     }
  4729.       else if (v)
  4730.     {
  4731.       if (GET_CODE (v->mult_val) == CONST_INT)
  4732.         *mult_val = gen_rtx (CONST_INT, VOIDmode,
  4733.                    INTVAL (v->mult_val) + 1);
  4734.       else
  4735.         return 0;
  4736.       *add_val = v->add_val;
  4737.       *forces = v;
  4738.       return ADD_BENEFIT;
  4739.     }
  4740.       else if (g)
  4741.     {
  4742.       *mult_val = g->mult_val;
  4743.       if (GET_CODE (g->add_val) == CONST_INT)
  4744.         *add_val = plus_constant (arg, INTVAL (g->add_val));
  4745.       else if (GET_CODE (arg) == CONST_INT)
  4746.         *add_val = plus_constant (g->add_val, INTVAL (arg));
  4747.       else
  4748.         /* Could succeed if arg == 0, but that will never occur.  */
  4749.         return 0;
  4750.  
  4751.       if (subexp)
  4752.         /* g deleted when return, can't return pointer to it */
  4753.         return ADD_BENEFIT + g->benefit;
  4754.       else
  4755.         {
  4756.           *forces = g;
  4757.           return ADD_BENEFIT;
  4758.         }
  4759.     }
  4760.       else
  4761.     {
  4762.       *mult_val = const1_rtx;
  4763.       *add_val = arg;
  4764.       return ADD_BENEFIT;
  4765.     }
  4766.  
  4767.       /* Takes a lot of code and will rarely succeed.  */
  4768.     case MINUS:
  4769.       if (v && g)
  4770.     {
  4771.       /* G is the first argument of MINUS.  */
  4772.  
  4773.       if (GET_CODE (g->mult_val) == CONST_INT)
  4774.         {
  4775.           if (g->mult_val == const0_rtx)
  4776. #if 0 /* Should not have to fail here */
  4777.         *mult_val = gen_rtx (NEG, SImode, v->mult_val);
  4778. #endif
  4779.         return 0;
  4780.           else if (GET_CODE (v->mult_val) == CONST_INT)
  4781.         *mult_val = gen_rtx (CONST_INT, VOIDmode,
  4782.                        INTVAL (g->mult_val)
  4783.                        - INTVAL (v->mult_val));
  4784.           else
  4785.         return 0;
  4786.         }
  4787.       else if (v->mult_val == const0_rtx)
  4788.         *mult_val = g->mult_val;
  4789.       else
  4790.         return 0;
  4791.  
  4792.       if (GET_CODE (g->add_val) == CONST_INT)
  4793.         {
  4794.           if (g->add_val == const0_rtx)
  4795. #if 0 /* should not have to fail here */
  4796.         *add_val = v->add_val;
  4797. #endif
  4798.         return 0;
  4799.           else if (GET_CODE (v->add_val) == CONST_INT)
  4800.         *add_val = gen_rtx (CONST_INT, VOIDmode,
  4801.                        INTVAL (g->add_val)
  4802.                        - INTVAL (v->add_val));
  4803.           else
  4804.         return 0;
  4805.         }
  4806.       else if (v->add_val == const0_rtx)
  4807.         *add_val = g->add_val;
  4808.       else
  4809.         return 0;
  4810.  
  4811.       if (subexp)
  4812.         {
  4813.           /* G deleted when return, can't return pointer to it */
  4814.           if (*forces2 == 0)
  4815.         *forces2 = v;
  4816.           return ADD_BENEFIT + g->benefit;
  4817.         }
  4818.       else
  4819.         {
  4820.           *forces = g;
  4821.           *forces2 = v;
  4822.           return ADD_BENEFIT;
  4823.         }
  4824.     }
  4825.       else if (v)
  4826.     {
  4827.       if (GET_CODE (v->mult_val) != CONST_INT)
  4828.         return 0;
  4829.       if (arg == XEXP (x, 0))             /* giv1 = giv2 - biv */
  4830.         {
  4831.           *mult_val = gen_rtx (CONST_INT, VOIDmode,
  4832.                      INTVAL (v->mult_val) - 1);
  4833.           *add_val = v->add_val;
  4834.         }
  4835.       else                                /* giv1 = biv - giv2 */
  4836.         {
  4837.           *mult_val = gen_rtx (CONST_INT, VOIDmode,
  4838.                      1 - INTVAL (v->mult_val));
  4839.           if (GET_CODE (v->add_val) == CONST_INT)
  4840.         *add_val = gen_rtx (CONST_INT, VOIDmode,
  4841.                       - INTVAL (v->add_val));
  4842.           else
  4843.         return 0;
  4844.         }
  4845.       *forces = v;
  4846.       return ADD_BENEFIT;
  4847.     }
  4848.       else if (g)
  4849.     {
  4850.       if (arg == XEXP (x, 1))
  4851.         *mult_val = g->mult_val;
  4852.       else
  4853.         {
  4854.           if (GET_CODE (g->mult_val) == CONST_INT)
  4855.         *mult_val = gen_rtx (CONST_INT, VOIDmode,
  4856.                        - INTVAL (g->mult_val));
  4857.           else
  4858.         return 0;
  4859.         }
  4860.       if (GET_CODE (g->add_val) == CONST_INT)
  4861.         {
  4862.           if (g->add_val == const0_rtx)
  4863.         {
  4864.           if (arg == XEXP (x, 1))    /* giv1 = giv2 - arg */
  4865.             {
  4866.               /* Fail unless arg is a constant.  */
  4867.               if (GET_CODE (arg) == CONST_INT)
  4868.             *add_val = gen_rtx (CONST_INT, VOIDmode,
  4869.                           -INTVAL (arg));
  4870.               else
  4871.             return 0;
  4872.             }
  4873.           else                       /* giv1 = arg - giv2 */
  4874.             *add_val = arg;
  4875.         }
  4876.           else if (GET_CODE (arg) == CONST_INT)
  4877.         {
  4878.           if (arg == XEXP (x, 1))   /* giv1 = giv2 - arg */
  4879.             *add_val = gen_rtx (CONST_INT, VOIDmode,
  4880.                       INTVAL (g->add_val)
  4881.                       - INTVAL (arg));
  4882.           else                      /* giv1 = arg - giv2 */
  4883.             *add_val = gen_rtx (CONST_INT, VOIDmode,
  4884.                       INTVAL (arg),
  4885.                       - INTVAL (g->add_val));
  4886.         }
  4887.           else
  4888.         return 0;
  4889.         }
  4890.       else
  4891.         /* Could succeed if arg == 0, but that will never occur.  */
  4892.         return 0;
  4893.  
  4894.       if (subexp)
  4895.         /* G deleted when return, can't return pointer to it.  */
  4896.         return ADD_BENEFIT + g->benefit;
  4897.       else
  4898.         {
  4899.           *forces = g;
  4900.           return ADD_BENEFIT;
  4901.         }
  4902.     }
  4903.       else if (GET_CODE (arg) == CONST_INT)
  4904.     {
  4905.       if (arg == XEXP (x, 1))
  4906.         {
  4907.           *add_val = gen_rtx (CONST_INT, VOIDmode, - INTVAL (arg));
  4908.           *mult_val = const1_rtx;
  4909.         }
  4910.       else
  4911.         {
  4912.           *add_val = arg;
  4913.           *mult_val = gen_rtx (CONST_INT, VOIDmode, -1);
  4914.         }
  4915.       return ADD_BENEFIT;
  4916.     }
  4917.       else
  4918.       return 0;
  4919.  
  4920.       /* UMULT can be handled like MULT since C ignores overflows.  */
  4921.     case MULT:
  4922.     case UMULT:
  4923.       if (v && g)
  4924.     {
  4925.       /* Quadratic term, just fail.  */
  4926.       return 0;
  4927.     }
  4928.       else if (v)
  4929.     {
  4930.       /* Quadratic term, just fail.  */
  4931.       return 0;
  4932.     }
  4933.       else if (g)
  4934.     {
  4935.       /* Takes a lot of code and will rarely succeed.  */
  4936.       /* dest = m * arg * b + a * arg */
  4937.       if (GET_CODE (g->mult_val) == CONST_INT)
  4938.         {
  4939.           if (g->mult_val == const0_rtx)
  4940.         *mult_val = const0_rtx;
  4941.           else if (g->mult_val == const1_rtx)
  4942.         *mult_val = arg;
  4943.           else if (GET_CODE (arg) == CONST_INT)
  4944.         *mult_val = gen_rtx (CONST_INT, VOIDmode,
  4945.                        INTVAL (g->mult_val) * INTVAL (arg));
  4946.           else
  4947.         return 0;
  4948.         }
  4949.       else
  4950.         /* Could suceed if arg == 1 or 0, but this will never occur.  */
  4951.         return 0;
  4952.  
  4953.       if (GET_CODE (g->add_val) == CONST_INT)
  4954.         {
  4955.           if (g->add_val == const0_rtx)
  4956.         *add_val = const0_rtx;
  4957.           else if (g->add_val == const1_rtx)
  4958.         *add_val = arg;
  4959.           else if (GET_CODE (arg) == CONST_INT)
  4960.         *add_val = gen_rtx (CONST_INT, VOIDmode,
  4961.                        INTVAL (g->add_val) * INTVAL (arg));
  4962.           else
  4963.         return 0;
  4964.         }
  4965.       else
  4966.         /* Could suceed if arg == 1 or 0, but this will never occur.  */
  4967.         return 0;
  4968.  
  4969.       if (subexp)
  4970.         /* G deleted when return, can't return pointer to it.  */
  4971.         return MULT_BENEFIT + g->benefit;
  4972.       else
  4973.         {
  4974.           *forces = g;
  4975.           return MULT_BENEFIT;
  4976.         }
  4977.     }
  4978.       else
  4979.     {
  4980.       *mult_val = arg;
  4981.       *add_val = const0_rtx;
  4982.       return MULT_BENEFIT;
  4983.     }
  4984.  
  4985.       /* These are not worth the trouble.  */
  4986.     case DIV:
  4987.     case UDIV:
  4988.       return 0;
  4989.  
  4990.       /* Handle these, but only for left shift.  */
  4991.     case LSHIFT:
  4992.     case ASHIFT:
  4993.       if (v && g)
  4994.     {
  4995.       /* Quadratic term, just fail.  */
  4996.       return 0;
  4997.     }
  4998.       else if (v)
  4999.     {
  5000.       /* Quadratic term, just fail.  */
  5001.       return 0;
  5002.     }
  5003.       else if (g)
  5004.     {
  5005.       /* Takes a lot of code and will rarely succeed.  */
  5006.       /* dest = ((m * b) << arg) + (a << arg) */
  5007.       if (GET_CODE (g->mult_val) == CONST_INT)
  5008.         {
  5009.           if (g->mult_val == const0_rtx)
  5010.         *mult_val = const0_rtx;
  5011.           else if (GET_CODE (arg) == CONST_INT && INTVAL (arg) >= 0)
  5012.         *mult_val = gen_rtx (CONST_INT, VOIDmode,
  5013.                        INTVAL (g->mult_val)
  5014.                        * (1 << INTVAL (arg)));
  5015.           else
  5016.         return 0;
  5017.         }
  5018.       else
  5019.         /* Could suceed if arg == 0, but this will never occur.  */
  5020.         return 0;
  5021.  
  5022.       if (GET_CODE (g->add_val) == CONST_INT)
  5023.         {
  5024.           if (g->add_val == const0_rtx)
  5025.         *add_val = const0_rtx;
  5026.           else if (GET_CODE (arg) == CONST_INT)
  5027.         *add_val = gen_rtx (CONST_INT, VOIDmode,
  5028.                        INTVAL (g->add_val)
  5029.                        * (1 << INTVAL (arg)));
  5030.           else
  5031.         return 0;
  5032.         }
  5033.       else
  5034.         /* Could suceed if arg == 0, but this will never occur.  */
  5035.         return 0;
  5036.  
  5037.       if (subexp)
  5038.         /* G deleted when return, can't return pointer to it.  */
  5039.         return SHIFT_BENEFIT + g->benefit;
  5040.       else
  5041.         {
  5042.           *forces = g;
  5043.           return SHIFT_BENEFIT;
  5044.         }
  5045.     }
  5046.  
  5047.       if (GET_CODE (arg) == CONST_INT && INTVAL (arg) >= 0)
  5048.     *mult_val = gen_rtx (CONST_INT, VOIDmode, 1 << INTVAL (arg));
  5049.       else
  5050.     return 0;
  5051.       *add_val = const0_rtx;
  5052.       return SHIFT_BENEFIT;
  5053.  
  5054.       /* These are not worth the trouble.  */
  5055.     case ASHIFTRT:
  5056.     case LSHIFTRT:
  5057.       return 0;
  5058.  
  5059.       /* should never reach here */
  5060.     default:
  5061.       abort ();
  5062.       return 0;
  5063.     }
  5064. }
  5065.  
  5066. /* Help detect a giv that is calculated by several consecutive insns;
  5067.    for example,
  5068.       giv = biv * M
  5069.       giv = giv + A
  5070.    The caller has already identified the first insn P as having a giv as dest;
  5071.    we check that all other insns that set the same register follow
  5072.    immediately after P, that they alter nothing else,
  5073.    and that the result of the last is still a giv.
  5074.  
  5075.    The value is 0 if the reg set in P is not really a giv.
  5076.    Otherwise, the value is the amount gained by eliminating
  5077.    all the consecutive insns that compute the value.
  5078.  
  5079.    FIRST_BENEFIT is the amount gained by eliminating the first insn, P.
  5080.    SRC_REGNO is the regno of the biv; DEST_REGNO is that of the giv.
  5081.  
  5082.    The coefficients of the ultimate giv value are stored in
  5083.    *MULT_VAL and *ADD_VAL.  */
  5084.  
  5085. static int
  5086. consec_sets_giv (first_benefit, p, src_regno, dest_regno,
  5087.          add_val, mult_val)
  5088.      int first_benefit;
  5089.      rtx p;
  5090.      int src_regno;
  5091.      int dest_regno;
  5092.      rtx *add_val;
  5093.      rtx *mult_val;
  5094. {
  5095.   int count;
  5096.   int benefit = first_benefit;
  5097.   enum rtx_code code;
  5098.   struct induction forces, forces2;
  5099.   rtx temp;
  5100.   int tem;
  5101.  
  5102.   /* Initialize info used by general_induction_var.  */
  5103.   struct induction *v =
  5104.     (struct induction *) oballoc (sizeof (struct induction));
  5105.   v->src_regno = src_regno;
  5106.   v->mult_val = *mult_val;
  5107.   v->add_val = *add_val;
  5108.  
  5109.   induct_var[dest_regno] = GENERAL_INDUCT;
  5110.   induct_struct[dest_regno] = v;
  5111.  
  5112.   count = n_times_set[dest_regno] - 1;
  5113.  
  5114.   while (count > 0)
  5115.     {
  5116.       p = NEXT_INSN (p);
  5117.       code = GET_CODE (p);
  5118.  
  5119.       /* If libcall, skip to end of call sequence.  */
  5120.       if (code == INSN && (temp = find_reg_note (p, REG_LIBCALL, 0)))
  5121.     p = XEXP (temp, 0);
  5122.  
  5123.       if (code == INSN && GET_CODE (PATTERN (p)) == SET
  5124.       && GET_CODE (SET_DEST (PATTERN (p))) == REG
  5125.       && REGNO (SET_DEST (PATTERN (p))) == dest_regno
  5126.       && ((tem = general_induction_var (SET_SRC (PATTERN (p)), &src_regno,
  5127.                         add_val, mult_val,
  5128.                         &forces, &forces2))
  5129.           /* Giv created by call to library routine.  */
  5130.           || ((temp = find_reg_note (p, REG_EQUAL, 0)) &&
  5131.           (tem = general_induction_var (XEXP (temp, 0), &src_regno,
  5132.                         add_val, mult_val,
  5133.                         &forces, &forces2))))
  5134.       && src_regno == v->src_regno)
  5135.     {
  5136.       count--;
  5137.       benefit += tem;
  5138.       v->mult_val = *mult_val;
  5139.       v->add_val = *add_val;
  5140.     }
  5141.       else if (code != NOTE)
  5142.     {
  5143.       induct_var[dest_regno] = UNKNOWN_INDUCT;
  5144.       return 0;
  5145.     }
  5146.     }
  5147.  
  5148.   return benefit;
  5149. }
  5150.  
  5151. /* Generate a SEQUENCE to multiply OP0 and OP1 with result in TARGET.
  5152.    Use expand_mult to "optimally" do the multiply.
  5153.    This also works for machines that do not have multiply insns.
  5154.    If one of the operands is a constant, it must be the second.  */
  5155.  
  5156. static rtx
  5157. gen_iv_mult (mode, op0, op1, target)
  5158.      enum machine_mode mode;
  5159.      register rtx op0, op1, target;
  5160. {
  5161.   extern rtx gen_sequence ();
  5162.   extern rtx start_sequence ();
  5163.   rtx saved, result, temp;
  5164.  
  5165.   saved = start_sequence ();
  5166.  
  5167.   /* ??? It is very unmodular to use expand_mult here!
  5168.      This should be redesigned.  */
  5169.  
  5170.   /* UNSIGNEDP arg can be zero since operands/target always same width.  */
  5171.   temp = expand_mult (mode, op0, op1, target, 0);
  5172.  
  5173.   /* Move to target register, if expand_mult did not put it there.  */
  5174.   if (target != 0 && temp != target)
  5175.     emit_move_insn (target, temp);
  5176.  
  5177.   result = gen_sequence ();
  5178.   end_sequence (saved);
  5179.  
  5180.   return result;
  5181. }
  5182.  
  5183. /* Emit code to initialize an induction variable created by strength
  5184.    reduction.
  5185.    More precisely, emit code before INSERT_BEFORE
  5186.    to set REG = B * M + A.  */
  5187.  
  5188. static void
  5189. emit_iv_init_code (b, m, a, reg, insert_before)
  5190.      rtx b;          /* initial value of basic induction variable */
  5191.      rtx m;          /* multiplicative constant */
  5192.      rtx a;          /* additive constant */
  5193.      rtx reg;        /* destination register */
  5194.      rtx insert_before;
  5195. {
  5196.   rtx seq;
  5197.   rtx result;
  5198.  
  5199.   /* Prevent unexpected sharing of these rtx.  */
  5200.   a = copy_rtx (a);
  5201.   b = copy_rtx (b);
  5202.  
  5203.   start_sequence ();
  5204. #if defined( DSP56000 ) || defined( DSP96000 )
  5205.   /* since we're the only fn to call expand_mult_add, we've augmented it
  5206.      to take target as an extra argument. see expmed.c for more details. */
  5207.   result = expand_mult_add (b, m, a, GET_MODE (reg), 0, reg);
  5208. #else
  5209.   result = expand_mult_add (b, m, a, GET_MODE (reg), 0);
  5210. #endif
  5211.   if (reg != result)
  5212.     emit_move_insn (reg, result);
  5213.   seq = gen_sequence ();
  5214.   end_sequence ();
  5215.  
  5216.   emit_insn_before (seq, insert_before);
  5217. }
  5218.  
  5219. /* Emit code to increment the induction variable inside the loop.
  5220.    Try to emit optimal code for the expression
  5221.    REG = REG + BIV_ADD * GIV_MULT.  */
  5222.  
  5223. static void
  5224. emit_iv_inc (biv_add, giv_mult, reg, insn)
  5225.      rtx biv_add;                   /* increment value for biv */
  5226.      rtx giv_mult;                  /* multiply value of giv */
  5227.      rtx reg;                       /* create insn to set this reg */
  5228.      rtx insn;                      /* where to insert the new insn */
  5229. {
  5230.   emit_iv_init_code (biv_add, giv_mult, reg, reg, insn);
  5231. }
  5232.  
  5233. /* Test whethen BIV_ADD * GIV_MULT can be computed without
  5234.    an actual multiply insn.  Value is 1 if so.  */
  5235.  
  5236. static int
  5237. product_cheap_p (biv_add, giv_mult)
  5238.      rtx biv_add;
  5239.      rtx giv_mult;
  5240. {
  5241.   /* Indicates which of MULT/ADD are constants.  */
  5242.   int status = 0;
  5243.   int const_val;
  5244.   rtx tmp;
  5245.  
  5246.   if (GET_CODE (biv_add) == CONST_INT)
  5247.     status |= 0x1;
  5248.   if (GET_CODE (giv_mult) == CONST_INT)
  5249.     status |= 0x2;
  5250.  
  5251.   switch (status)
  5252.     {
  5253.     case 0:
  5254.       /* Neither is constant: would need a multiply insn, so fail.  */
  5255.       return 0;
  5256.  
  5257.     case 1:
  5258.       /* BIV_ADD value is constant */
  5259.       /* Equivalent to state 2, just switch values of BIV_ADD and GIV_MULT
  5260.      and fall through.  */
  5261.       tmp = biv_add;
  5262.       biv_add = giv_mult;
  5263.       giv_mult = tmp;
  5264.  
  5265.     case 2:
  5266.       /* GIV_MULT value is constant.
  5267.      If it is 1, 0 or -1 then we win.  */
  5268.       const_val = INTVAL (giv_mult);
  5269.       if (const_val < -1 || const_val > 1)
  5270.     {
  5271.       tmp = gen_iv_mult (GET_MODE (biv_add), biv_add, giv_mult, 0);
  5272.       /* Don't emit a multiply insn, just fail instead.  */
  5273.       if ((GET_CODE (tmp) == SET && GET_CODE (SET_SRC (tmp)) == MULT)
  5274.              /* Also fail if library call (which generates more
  5275.             then two insn) is needed.  */
  5276.           || (GET_CODE (tmp) == SEQUENCE && XVECLEN (tmp, 0) > 2))
  5277.         return 0;
  5278.     }
  5279.       return 1;
  5280.  
  5281.     case 3:
  5282.       /* Both BIV_ADD and GIV_MULT are constant;
  5283.      can compute the product at compile time.  */
  5284.       return 1;
  5285.  
  5286.     default:
  5287.       abort ();
  5288.     }
  5289. }
  5290.  
  5291.  
  5292. /* Check to see if loop can be terminated by a "decrement and branch until
  5293.    zero" instruction.  If so, add a REG_NONNEG note to the branch insn if so.
  5294.    Also try reversing an increment loop to a decrement loop
  5295.    to see if the optimization can be performed.
  5296.    Value is nonzero if optimization was performed.  */
  5297.  
  5298. static int
  5299. check_dbra_loop (loop_end, iv_list, insn_count, loop_start)
  5300.      rtx loop_end;
  5301.      struct iv_class *iv_list;
  5302.      int insn_count;
  5303.      rtx loop_start;
  5304. {
  5305.   struct iv_class *bl;
  5306.   rtx reg;
  5307.   rtx jump_label;
  5308.   rtx final_value;
  5309.   rtx start_value;
  5310.   enum rtx_code branch_code;
  5311.   rtx new_add_val;
  5312.   rtx tested_before_loop = 0;
  5313.   rtx p;
  5314.  
  5315.   /* See if the loop is contained in  `if (X >= 0)' for some reg X.
  5316.      If so, then we know X is initially nonnegative even though
  5317.      we don't know its initial value.
  5318.      Record X in TESTED_BEFORE_LOOP.  */
  5319.  
  5320.   for (p = loop_start; p != 0; p = PREV_INSN (p))
  5321.     if (GET_CODE (p) != NOTE)
  5322.       break;
  5323.  
  5324.   /* See if a conditional branch preceeds the loop.
  5325.      There may be no other insns or labels between it and
  5326.      the beginning of the loop.  */
  5327.   if (p != 0 && GET_CODE (p) == JUMP_INSN && condjump_p (p)
  5328.       && SET_SRC (PATTERN (p)) != pc_rtx
  5329.       && ((GET_CODE (XEXP (SET_SRC (PATTERN (p)), 0)) == LT
  5330.        && XEXP (SET_SRC (PATTERN (p)), 2) == pc_rtx)
  5331.       ||
  5332.       (GET_CODE (XEXP (SET_SRC (PATTERN (p)), 0)) == GE
  5333.        && XEXP (SET_SRC (PATTERN (p)), 1) == pc_rtx))
  5334.       && next_real_insn (JUMP_LABEL (p)) == next_real_insn (loop_end))
  5335.     {
  5336.       /* Before the branch should be a test or compare.
  5337.      See if we are comparing something against zero.  */
  5338.       p = PREV_INSN (p);
  5339.       if (GET_CODE (p) == INSN && GET_CODE (PATTERN (p)) == SET
  5340.       && SET_DEST (PATTERN (p)) == cc0_rtx)
  5341.     {
  5342.       if (GET_CODE (SET_SRC (PATTERN (p))) == REG)
  5343.         tested_before_loop = SET_SRC (PATTERN (p));
  5344.       else if (GET_CODE (SET_SRC (PATTERN (p))) == COMPARE
  5345.            && GET_CODE (XEXP (SET_SRC (PATTERN (p)), 0)) == REG
  5346.            && XEXP (SET_SRC (PATTERN (p)), 1) == const0_rtx)
  5347.         tested_before_loop = XEXP (SET_SRC (PATTERN (p)), 0);
  5348.       else if (GET_CODE (SET_SRC (PATTERN (p))) == COMPARE
  5349.            && GET_CODE (XEXP (SET_SRC (PATTERN (p)), 1)) == REG
  5350.            && XEXP (SET_SRC (PATTERN (p)), 0) == const0_rtx)
  5351.         tested_before_loop = XEXP (SET_SRC (PATTERN (p)), 1);
  5352.     }
  5353.     }
  5354.  
  5355.   /* If last insn is a conditional branch, and the insn before tests a register
  5356.      value, then try to optimize it.  */
  5357.  
  5358.   if (GET_CODE (PREV_INSN (loop_end)) == JUMP_INSN
  5359.       && GET_CODE (PATTERN (PREV_INSN (loop_end))) == SET
  5360.       && GET_CODE (SET_SRC (PATTERN (PREV_INSN (loop_end)))) == IF_THEN_ELSE
  5361.       && GET_CODE (PREV_INSN (PREV_INSN (loop_end))) == INSN
  5362.       && GET_CODE (PATTERN (PREV_INSN (PREV_INSN (loop_end)))) == SET
  5363.       && (GET_CODE (SET_DEST (PATTERN (PREV_INSN (PREV_INSN (loop_end))))) ==
  5364.       CC0))
  5365.     {
  5366.       /* Check all of the bivs to see if the compare uses one of them.  */
  5367.  
  5368.       for (bl = iv_list; bl; bl = bl->next)
  5369.     {
  5370.       if (reg_mentioned_p (SET_DEST (PATTERN (bl->biv->insn)),
  5371.                    PREV_INSN (PREV_INSN (loop_end))))
  5372.         break;
  5373.     }
  5374.  
  5375.       /* If biv set more than once, then give up.
  5376.      We can't guarantee that it will be zero on the last iteration.
  5377.      Also give up if the biv is used between its update and the test
  5378.      insn.  */
  5379.       if (bl && bl->biv_count == 1
  5380.       && ! reg_used_between_p (regno_reg_rtx[bl->regno], bl->biv->insn,
  5381.                    PREV_INSN (PREV_INSN (loop_end))))
  5382.     {
  5383.       /* Look for the case where the basic induction variable is always
  5384.          nonnegative, and equals zero on the last iteration.
  5385.          In this case, add a reg_note REG_NONNEG, which allows the
  5386.          m68k DBRA instruction to be used.  */
  5387.  
  5388.       /* the decrement case */
  5389.  
  5390.       if (GET_CODE (bl->biv->add_val) == CONST_INT
  5391.           && INTVAL (bl->biv->add_val) < 0)
  5392.         {
  5393.           /* Initial value must be greater than 0,
  5394.          init_val % -dec_value == 0 to ensure that it equals zero on
  5395.             the last iteration */
  5396.  
  5397.           if (GET_CODE (bl->initial_value) == CONST_INT
  5398.           && INTVAL (bl->initial_value) > 0
  5399.           && (INTVAL (bl->initial_value) %
  5400.               (-INTVAL (bl->biv->add_val))) == 0)
  5401.         {
  5402.           /* register always nonnegative, add REG_NOTE to branch */
  5403.           REG_NOTES (PREV_INSN (loop_end))
  5404.             = gen_rtx (EXPR_LIST, REG_NONNEG, 0,
  5405.                    REG_NOTES (PREV_INSN (loop_end)));
  5406.           bl->nonneg = 1;
  5407.  
  5408.           return 1;
  5409.         }
  5410.  
  5411.           /* If the decrement is 1 and the value was tested as >= 0 before
  5412.          the loop, then we can safely optimize.  */
  5413.           if (SET_DEST (PATTERN (bl->biv->insn)) == tested_before_loop
  5414.           && INTVAL (bl->biv->add_val) == -1)
  5415.         {
  5416.           REG_NOTES (PREV_INSN (loop_end))
  5417.             = gen_rtx (EXPR_LIST, REG_NONNEG, 0,
  5418.                    REG_NOTES (PREV_INSN (loop_end)));
  5419.           bl->nonneg = 1;
  5420.  
  5421.           return 1;
  5422.         }
  5423.         }
  5424.       else if (num_mem_sets <= 1)
  5425.         {
  5426.           /* Try to change inc to dec, so can apply above optimization.  */
  5427.           /* Can do this if:
  5428.          all registers modified are induction variables or invariant,
  5429.          all memory references have non-overlapping addresses
  5430.                        (obviously true if only one write)
  5431.              allow 2 insns for the compare/jump at the end of the loop.  */
  5432.           int num_nonfixed_reads = 0;
  5433.           rtx p;
  5434.  
  5435.           for (p = loop_start; p != loop_end; p = NEXT_INSN (p))
  5436.         if (GET_CODE (p) == INSN || GET_CODE (p) == CALL_INSN
  5437.             || GET_CODE (p) == JUMP_INSN)
  5438.           num_nonfixed_reads += count_nonfixed_reads (PATTERN (p));
  5439.  
  5440.           /* This code only acts for innermost loops.  Also it simplifies
  5441.          the memory address check by only reversing loops with
  5442.          zero or one memory access.
  5443.          Two memory accesses could involve parts of the same array,
  5444.          and that can't be reversed.  */
  5445.  
  5446.           if (num_nonfixed_reads <= 1
  5447.           && !loop_has_call
  5448.           && (bl->giv_count + bl->biv_count + num_mem_sets
  5449.               + num_movables + 2 == insn_count))
  5450.         {
  5451.           rtx src_two_before_end;
  5452.           int constant;
  5453.           int win;
  5454.  
  5455.           /* Loop can be reversed.  */
  5456.           if (loop_dump_stream)
  5457.             fprintf (loop_dump_stream, "Can reverse loop\n");
  5458.  
  5459.           /* Now check other conditions:
  5460.              initial_value must be zero,
  5461.              final_value % add_val == 0, so that when reversed, the
  5462.              biv will be zero on the last iteration.  */
  5463.  
  5464.           /* Calculating the final value non trivial.
  5465.              If branch is (LT (CC0) (CONST 0),
  5466.              then value in compare is final value.
  5467.              If branch is (LE (CC0) (CONST 0),
  5468.              then value in compare is final_value - add_val */
  5469.  
  5470.           branch_code
  5471.             = GET_CODE (XEXP (SET_SRC (PATTERN (PREV_INSN (loop_end))), 0));
  5472.           src_two_before_end
  5473.             = SET_SRC (PATTERN (PREV_INSN (PREV_INSN (loop_end))));
  5474.  
  5475.           win = 1;
  5476.           if (GET_CODE (src_two_before_end) == REG)
  5477.             constant = 0;
  5478.           else if (GET_CODE (src_two_before_end) == COMPARE
  5479.                && GET_CODE (XEXP (src_two_before_end, 1)) == CONST_INT)
  5480.             constant = INTVAL (XEXP (src_two_before_end, 1));
  5481.           else
  5482.             win = 0;
  5483.  
  5484.           if (win && bl->initial_value == const0_rtx
  5485.               && (branch_code == LT || branch_code == LE)
  5486.               && XEXP (XEXP (SET_SRC (PATTERN (PREV_INSN (loop_end))), 0), 1) == const0_rtx
  5487.               && (constant % INTVAL (bl->biv->add_val)) == 0)
  5488.             {
  5489.               /* Register will always be nonnegative, with value
  5490.              0 on last iteration if loop reversed */
  5491.  
  5492.               /* Save some info needed to produce the new insns.  */
  5493.               reg = SET_DEST (PATTERN (bl->biv->insn));
  5494.               jump_label = XEXP (SET_SRC (PATTERN (PREV_INSN (loop_end))), 1);
  5495.               new_add_val = gen_rtx (CONST_INT, VOIDmode,
  5496.                          - INTVAL (bl->biv->add_val));
  5497.  
  5498.  
  5499.               if (branch_code == LT)
  5500.             {
  5501.               final_value
  5502.                 = gen_rtx (CONST_INT, VOIDmode, constant);
  5503.               start_value
  5504.                 = gen_rtx (CONST_INT, VOIDmode,
  5505.                        (constant - INTVAL (bl->biv->add_val)));
  5506.             }
  5507.               else /* branch_code == LE */
  5508.             {
  5509.               start_value
  5510.                 = gen_rtx (CONST_INT, VOIDmode, constant);
  5511.               final_value
  5512.                 = gen_rtx (CONST_INT, VOIDmode,
  5513.                        (constant + INTVAL (bl->biv->add_val)));
  5514.             }
  5515.  
  5516.               /* Initialize biv to start_value before loop start.
  5517.              The old initializing insn will be deleted as a
  5518.              dead store by flow.c.  */
  5519.               emit_insn_before (gen_rtx (SET, VOIDmode, reg,
  5520.                          start_value),
  5521.                     loop_start);
  5522.  
  5523.               /* Add insn to decrement register, and delete insn
  5524.              that incremented the register.  */
  5525.               emit_insn_before (gen_rtx (SET, VOIDmode, reg,
  5526.                       gen_rtx (PLUS, GET_MODE (reg), reg,
  5527.                            new_add_val)),
  5528.                     bl->biv->insn);
  5529.               /* Update biv info to reflect its new status.  */
  5530.               bl->biv->insn = PREV_INSN (bl->biv->insn);
  5531.               delete_insn (NEXT_INSN (bl->biv->insn));
  5532.  
  5533.               /* Inc LABEL_NUSES so that delete_insn will
  5534.              not delete the label.  */
  5535.               LABEL_NUSES (XEXP (jump_label, 0)) ++;
  5536.  
  5537.               if (regno_last_uid[bl->regno] != INSN_UID (PREV_INSN (loop_end)))
  5538.             emit_insn_after (gen_rtx (SET, VOIDmode, reg,
  5539.                           final_value),
  5540.                      loop_end);
  5541.  
  5542.               /* Delete compare/branch at end of loop.  */
  5543.               delete_insn (PREV_INSN (loop_end));
  5544.               delete_insn (PREV_INSN (loop_end));
  5545.  
  5546.               /* Add new compare/branch insn at end of loop.  */
  5547.               emit_insn_before (gen_rtx (SET, VOIDmode, cc0_rtx, reg),
  5548.                     loop_end);
  5549.               emit_jump_insn_before (gen_rtx (SET, VOIDmode, pc_rtx,
  5550.                      gen_rtx (IF_THEN_ELSE, VOIDmode,
  5551.                          gen_rtx (GE, VOIDmode, cc0_rtx,
  5552.                               const0_rtx),
  5553.                          jump_label,
  5554.                          pc_rtx)),
  5555.                       loop_end);
  5556.  
  5557.               JUMP_LABEL (PREV_INSN (loop_end)) = XEXP (jump_label, 0);
  5558.               /* Increment of LABEL_NUSES done above. */
  5559.  
  5560.               /* Register is now always nonnegative,
  5561.              so add REG_NONNEG note to the branch.  */
  5562.               REG_NOTES (PREV_INSN (loop_end))
  5563.             = gen_rtx (EXPR_LIST, REG_NONNEG, 0,
  5564.                    REG_NOTES (PREV_INSN (loop_end)));
  5565.               bl->nonneg = 1;
  5566.  
  5567.               /* Update rest of biv info.  */
  5568.               bl->initial_value = start_value;
  5569.               bl->biv->add_val = new_add_val;
  5570.  
  5571.               if (loop_dump_stream)
  5572.             fprintf (loop_dump_stream, "Reversed loop and added reg_nonneg\n");
  5573.  
  5574.               return 1;
  5575.             }
  5576.         }
  5577.         }
  5578.     }
  5579.     }
  5580.   return 0;
  5581. }
  5582.  
  5583. /* Verify whether the biv BL appears to be eliminable,
  5584.    based on the insns in the loop that refer to it.
  5585.    LOOP_START is the first insn of the loop, and END is the end insn.  */
  5586.  
  5587. static void
  5588. check_eliminate_biv (bl, loop_start, end)
  5589.      struct iv_class *bl;
  5590.      rtx loop_start;
  5591.      rtx end;
  5592. {
  5593.   /* Get the REG rtx for the biv.  */
  5594.   rtx reg = SET_DEST (PATTERN (bl->biv->insn));
  5595.   rtx p;
  5596.   struct induction *v;
  5597.  
  5598.   bl->eliminable = 0;
  5599.  
  5600.   for (p = loop_start; p != end; p = NEXT_INSN (p))
  5601.     {
  5602.       enum rtx_code code = GET_CODE (p);
  5603.       if ((code == INSN || code == JUMP_INSN || code == CALL_INSN)
  5604.       && reg_mentioned_p (reg, PATTERN (p)))
  5605.     {
  5606.       /* This insn uses the biv.  If we can't understand it,
  5607.          then we can't eliminate the biv.  */
  5608.       if (GET_CODE (PATTERN (p)) != SET)
  5609.         {
  5610.           if (loop_dump_stream)
  5611.         fprintf (loop_dump_stream,
  5612.              "Cannot eliminate biv %d: cannot understand insn %d.\n",
  5613.              bl->regno, INSN_UID (p));
  5614.           break;
  5615.         }
  5616.  
  5617.       /* The insns that increment the biv are no problem.  */
  5618.       if (SET_DEST (PATTERN (p)) == reg)
  5619.         continue;
  5620.  
  5621.       /* If this is an insn which uses the biv ONLY in the
  5622.          calculation of a giv which is in the family of this
  5623.          biv, it's ok becuase it will go away when the giv is
  5624.          reduced.  March 14, 1989 -- self@bayes.arc.nasa.gov */
  5625.       for (v = bl->giv; v; v = v->family)
  5626.         if (v->insn == p)
  5627.           {
  5628.         if (v->giv_type == DEST_REG
  5629.             || (v->giv_type == DEST_ADDR
  5630.             /* Test was backwards - rms, 5 Dec 89 */
  5631.             && only_reg_use_p (reg, *(v->location),
  5632.                        PATTERN (p))))
  5633.           break;
  5634.           }
  5635.       if (v)
  5636.         continue;
  5637.  
  5638.       /* If can rewrite this insn not to use the biv, it's ok.  */
  5639.       if (can_eliminate_biv_p (p, bl))
  5640.         continue;
  5641.  
  5642.       /* Biv is used in a way we cannot eliminate.  */
  5643.       if (loop_dump_stream)
  5644.         fprintf (loop_dump_stream,
  5645.              "Cannot eliminate biv %d: biv used in insn %d.\n",
  5646.              bl->regno, INSN_UID (p));
  5647.       break;
  5648.     }
  5649.     }
  5650.  
  5651.   if (p == end)
  5652.     {
  5653.       bl->eliminable = 1;
  5654.       if (loop_dump_stream)
  5655.     fprintf (loop_dump_stream, "Can eliminate biv %d.\n",
  5656.          bl->regno);
  5657.     }
  5658. }
  5659.  
  5660. /* Return 1 if INSN, a compare insn which tests the biv described by BL,
  5661.    can be rewritten to use instead some reduced giv related to that biv.
  5662.    Does not change the rtl.
  5663.  
  5664.    We make the assumption that all the givs depending on this biv
  5665.    will be reduced, since only in that case will an attempt to eliminate
  5666.    the biv actually be made.
  5667.  
  5668.    The following function is very parallel to this one.  */
  5669.  
  5670. static int
  5671. can_eliminate_biv_p (insn, bl)
  5672.      rtx insn;
  5673.      struct iv_class *bl;
  5674. {
  5675.   rtx src;
  5676.   enum rtx_code code;
  5677.   struct induction *v, *tv;
  5678.   rtx arg;
  5679.   int arg_operand;
  5680.   /* Mode of this biv.  */
  5681.   enum machine_mode mode = bl->biv->mode;
  5682.  
  5683.   if (SET_DEST (PATTERN (insn)) != cc0_rtx)
  5684.     return 0;
  5685.  
  5686.   src = SET_SRC (PATTERN (insn));
  5687.   code = GET_CODE (src);
  5688.  
  5689.   switch (code)
  5690.     {
  5691.       /* a test insn */
  5692.     case REG:
  5693.       /* Can replace with any giv that has (MULT_VAL != 0) and (ADD_VAL == 0)
  5694.      Require a constant integer for MULT_VAL, so we know it's nonzero.  */
  5695.  
  5696.       for (v = bl->giv; v; v = v->family)
  5697.     if (GET_CODE (v->mult_val) == CONST_INT && v->mult_val != const0_rtx
  5698.         && v->add_val == const0_rtx
  5699.         && ! v->ignore
  5700.         && v->mode == mode)
  5701.       return 1;
  5702.  
  5703.       /* Look for a giv with (MULT_VAL != 0) and (ADD_VAL != 0)
  5704.      where ADD_VAL is a constant or a register;
  5705.      can replace test insn with a compare insn (cmp REDUCED_GIV ADD_VAL).
  5706.      Require a constant integer for MULT_VAL, so we know it's nonzero.  */
  5707.  
  5708.       for (v = bl->giv; v; v = v->family)
  5709.     if (GET_CODE (v->mult_val) == CONST_INT && v->mult_val != const0_rtx
  5710.         && (GET_CODE (v->add_val) == REG || GET_CODE (v->add_val) == CONST_INT)
  5711.         && ! v->ignore
  5712.         && v->mode == mode)
  5713.       return 1;
  5714.  
  5715.       if (loop_dump_stream)
  5716.     fprintf (loop_dump_stream, "Cannot eliminate biv %d in test insn %d: no appropriate giv.\n",
  5717.          bl->regno, INSN_UID (insn));
  5718.  
  5719.       return 0;
  5720.  
  5721.       /* a compare insn */
  5722.     case COMPARE:
  5723.       /* Figure out which operand is the biv.  */
  5724.       if ((GET_CODE (XEXP (src, 0)) == REG)
  5725.       && (REGNO (XEXP (src, 0)) == bl->regno))
  5726.     {
  5727.       arg = XEXP (src, 1);
  5728.       arg_operand = 1;
  5729.     }
  5730.       else if ((GET_CODE (XEXP (src, 1)) == REG)
  5731.            && (REGNO (XEXP (src, 1)) == bl->regno))
  5732.     {
  5733.       arg = XEXP (src, 0);
  5734.       arg_operand = 0;
  5735.     }
  5736.       else
  5737.     return 0;
  5738.  
  5739.       if (GET_CODE (arg) == CONST_INT)
  5740.     {
  5741.       /* Can replace with any giv that has constant coefficients.  */
  5742.  
  5743.       for (v = bl->giv; v; v = v->family)
  5744.         if (GET_CODE (v->mult_val) == CONST_INT
  5745.         && GET_CODE (v->add_val) == CONST_INT
  5746.         && ! v->ignore
  5747.         && v->mode == mode)
  5748.           return 1;
  5749.  
  5750.       /* Look for giv with constant mult_val and nonconst add_val,
  5751.          since we can insert add insn before loop
  5752.          to calculate new compare value.  */
  5753.  
  5754.       for (v = bl->giv; v; v = v->family)
  5755.         if (GET_CODE (v->mult_val) == CONST_INT
  5756.         && ! v->ignore
  5757.         && v->mode == mode)
  5758.           return 1;
  5759.     }
  5760.       else if (GET_CODE (arg) == REG || GET_CODE (arg) == MEM)
  5761.     {
  5762.       /* Comparing against invariant register or memref can be handled.  */
  5763.  
  5764.       if (invariant_p (arg))
  5765.         {
  5766.           /* Look for giv with constant mult_val and nonconst add_val.
  5767.          Insert add-insn before loop to compute new compare value.  */
  5768.  
  5769.           for (v = bl->giv; v; v = v->family)
  5770.         if ((GET_CODE (v->mult_val) == CONST_INT)
  5771.             && ! v->ignore
  5772.             && v->mode == mode)
  5773.           return 1;
  5774.         }
  5775.  
  5776.       /* Otherwise, only comparing against a biv can be handled.  */
  5777.       if (GET_CODE (arg) != REG
  5778.           || induct_var[REGNO (arg)] != BASIC_INDUCT)
  5779.         return 0;
  5780.  
  5781.       /* Look for a giv for each biv that have identical
  5782.          values for mult_val and add_val.  */
  5783.       for (v = bl->giv; v; v = v->family)
  5784.         if (v->mode == mode
  5785.         && ! v->ignore)
  5786.           {
  5787.         for (tv = class_struct[REGNO (arg)]->giv; tv; tv = tv->family)
  5788.           if ((tv->new_reg != 0)
  5789.               && rtx_equal_p (tv->mult_val, v->mult_val)
  5790.               && rtx_equal_p (tv->mult_val, v->mult_val)
  5791.               && ! tv->ignore
  5792.               && tv->mode == mode)
  5793.             return 1;
  5794.           }
  5795.     }
  5796.       return 0;
  5797.  
  5798.     default:
  5799.       return 0;
  5800.     }
  5801. }
  5802.  
  5803. /* Rewrite a compare insn INSN which uses the biv described by BL
  5804.    so that it doesn't use that biv any more.
  5805.    Instead it will use some reduced giv related to that biv.
  5806.  
  5807.    The preceding function is very parallel to this one.  */
  5808.  
  5809. static void
  5810. eliminate_biv (insn, bl, loop_start)
  5811.      rtx insn;
  5812.      struct iv_class *bl;
  5813.      rtx loop_start;
  5814. {
  5815.   rtx src = SET_SRC (PATTERN (insn));
  5816.   enum rtx_code code = GET_CODE (src);
  5817.   struct induction *v, *tv;
  5818.   rtx arg;
  5819.   int arg_operand;
  5820.   /* Mode of this biv.  */
  5821.   enum machine_mode mode = bl->biv->mode;
  5822.  
  5823.   switch (code)
  5824.     {
  5825.       /* a test insn */
  5826.     case REG:
  5827.       /* Can replace with any giv that was reduced and
  5828.      that has (MULT_VAL != 0) and (ADD_VAL == 0).
  5829.      Require a constant integer for MULT_VAL, so we know it's nonzero.  */
  5830.  
  5831.       for (v = bl->giv; v; v = v->family)
  5832.     if (GET_CODE (v->mult_val) == CONST_INT && v->mult_val != const0_rtx
  5833.         && v->add_val == const0_rtx
  5834.         && v->new_reg != 0
  5835.         && v->mode == mode)
  5836.       break;
  5837.       if (v)
  5838.     {
  5839.       /* We can test the sign of that giv's reduced reg.  */
  5840.       SET_SRC (PATTERN (insn)) = v->new_reg;
  5841.       return;
  5842.     }
  5843.  
  5844.       /* Look for a giv with (MULT_VAL != 0) and (ADD_VAL != 0)
  5845.      where ADD_VAL is a constant or a register;
  5846.      replace test insn with a compare insn (cmp REDUCED_GIV ADD_VAL).
  5847.      Require a constant integer for MULT_VAL, so we know it's nonzero.  */
  5848.  
  5849.       for (v = bl->giv; v; v = v->family)
  5850.     if (GET_CODE (v->mult_val) == CONST_INT && v->mult_val != const0_rtx
  5851.         && (GET_CODE (v->add_val) == REG || GET_CODE (v->add_val) == CONST_INT)
  5852.         && v->new_reg != 0
  5853.         && v->mode == mode)
  5854.       break;
  5855.       if (v)
  5856.     {
  5857.       /* Replace biv with the giv's reduced register.  */
  5858.       SET_SRC (PATTERN (insn)) = gen_rtx (COMPARE, GET_MODE (v->new_reg),
  5859.                           v->new_reg,
  5860.                           copy_rtx (v->add_val));
  5861.  
  5862. #if 0
  5863.       /* add_val must be invariant, so don't bother storing in a register */
  5864.       /* calculate the appropriate constant to compare against */
  5865.       emit_insn_before (gen_rtx (SET, VOIDmode, compare_value,
  5866.                      copy_rtx (v->add_val)),
  5867.                 loop_start);
  5868. #endif
  5869.       return;
  5870.     }
  5871.       abort ();
  5872.       break;
  5873.  
  5874.       /* a compare insn */
  5875.     case COMPARE:
  5876.       /* Figure out which operand is the biv.  */
  5877.       if (GET_CODE (XEXP (src, 0)) == REG
  5878.       && REGNO (XEXP (src, 0)) == bl->regno)
  5879.     {
  5880.       arg = XEXP (src, 1);
  5881.       arg_operand = 1;
  5882.     }
  5883.       else if (GET_CODE (XEXP (src, 1)) == REG
  5884.            && REGNO (XEXP (src, 1)) == bl->regno)
  5885.     {
  5886.       arg = XEXP (src, 0);
  5887.       arg_operand = 0;
  5888.     }
  5889.       else
  5890.     abort ();
  5891.  
  5892.       if (GET_CODE (arg) == CONST_INT)
  5893.     {
  5894.       /* Can replace with any giv that has constant mult_val and add_val.
  5895.          Make sure it was strength reduced by checking new_reg != 0.  */
  5896.  
  5897.       for (v = bl->giv; v; v = v->family)
  5898.         if (GET_CODE (v->mult_val) == CONST_INT
  5899.         && GET_CODE (v->add_val) == CONST_INT
  5900.         && v->new_reg
  5901.         && v->mode == mode)
  5902.           break;
  5903.       if (v)
  5904.         {
  5905.           rtx newval;
  5906.           /* Replace biv with the giv's reduced reg.  */
  5907.           XEXP (src, 1-arg_operand) = v->new_reg;
  5908.           /* Calculate the appropriate constant to compare against.  */
  5909.           newval = gen_rtx (CONST_INT, VOIDmode,
  5910.                 (INTVAL (arg) * INTVAL (v->mult_val)
  5911.                  + INTVAL (v->add_val)));
  5912.           XEXP (src, arg_operand) = newval;
  5913.           /* If that constant is no good in a compare,
  5914.          put it in a register.  */
  5915.           if (recog (PATTERN (insn), insn) < 0)
  5916.         {
  5917.           rtx temp = gen_reg_rtx (mode);
  5918.           emit_iv_init_code (arg, v->mult_val, v->add_val,
  5919.                      temp, loop_start);
  5920.           XEXP (src, arg_operand) = temp;
  5921.         }
  5922.           return;
  5923.         }
  5924.  
  5925.       /* Look for giv with constant mult_val and nonconst add_val.
  5926.          Insert add insn before loop to calculate new compare value.  */
  5927.  
  5928.       for (v = bl->giv; v; v = v->family)
  5929.         if (GET_CODE (v->mult_val) == CONST_INT
  5930.         && v->new_reg
  5931.         && v->mode == mode)
  5932.           break;
  5933.       if (v)
  5934.         {
  5935.           rtx compare_value = gen_reg_rtx (mode);
  5936.  
  5937.           /* Replace biv with giv's reduced register.  */
  5938.           XEXP (src, 1-arg_operand) = v->new_reg;
  5939.  
  5940.           /* At start of loop, compute value to compare against.  */
  5941.           emit_iv_init_code (arg, v->mult_val, v->add_val,
  5942.                  compare_value, loop_start);
  5943.           /* Use it in this insn.  */
  5944.           XEXP (src, arg_operand) = compare_value;
  5945.           return;
  5946.         }
  5947.       abort ();
  5948.     }
  5949.       else if (GET_CODE (arg) == REG || GET_CODE (arg) == MEM)
  5950.     {
  5951.       if (invariant_p (arg))
  5952.         {
  5953.           /* Look for giv with constant mult_val and nonconst add_val.
  5954.          Insert add-insn before loop to compute new compare value.  */
  5955.  
  5956.           for (v = bl->giv; v; v = v->family)
  5957.         if (GET_CODE (v->mult_val) == CONST_INT
  5958.             && v->new_reg
  5959.             && v->mode == mode)
  5960.           break;
  5961.           if (v)
  5962.         {
  5963.           rtx compare_value = gen_reg_rtx (mode);
  5964.  
  5965.           /* Replace biv with giv's reduced register.  */
  5966.           XEXP (src, 1-arg_operand) = v->new_reg;
  5967.  
  5968.           /* At start of loop, compute value to compare against.  */
  5969.           emit_iv_init_code (arg, v->mult_val, v->add_val,
  5970.                      compare_value, loop_start);
  5971.           XEXP (src, arg_operand) = compare_value;
  5972.           return;
  5973.         }
  5974.         }
  5975.  
  5976.       /* Otherwise the reg compared with had better be a biv.  */
  5977.       if (GET_CODE (arg) != REG
  5978.           || induct_var[REGNO (arg)] != BASIC_INDUCT)
  5979.         abort ();
  5980.  
  5981.       /* Look for a pair of givs, one for each biv,
  5982.          with identical coefficients.  */
  5983.       for (v = bl->giv; v; v = v->family)
  5984.         {
  5985.           if (!v->new_reg && v->mode == mode)
  5986.         continue;
  5987.           for (tv = class_struct[REGNO (arg)]->giv; tv; tv = tv->family)
  5988.         if ((tv->new_reg != 0)
  5989.             && rtx_equal_p (tv->mult_val, v->mult_val)
  5990.             && rtx_equal_p (tv->add_val, v->add_val)
  5991.             && tv->mode == mode)
  5992.           break;
  5993.           if (tv)
  5994.         break;
  5995.         }
  5996.       if (v)
  5997.         {
  5998.           /* Replace biv with its giv's reduced reg.  */
  5999.           XEXP (src, 1-arg_operand) = v->new_reg;
  6000.           /* Replace other operand with the other giv's reduced reg.  */
  6001.           XEXP (src, arg_operand) = tv->new_reg;
  6002.           return;
  6003.         }
  6004.     }
  6005.       abort ();
  6006.  
  6007.     default:
  6008.       abort ();
  6009.     }
  6010. }
  6011.  
  6012. /* Try to calculate the final value of the biv,
  6013.    the value it will have at the end of the loop.
  6014.    If we can do it, return that value.  */
  6015.  
  6016. /* ??? One case that should be simple to handle
  6017.    is when the biv is incremented by an invariant
  6018.    exactly once each time around the loop,
  6019.    and when the number of iterations can be determined
  6020.    (as the value of some invariant).
  6021.    Then the final value would be BIV + (INCREMENT * NUM_ITERATIONS).
  6022.  
  6023.    Once that case is handled, it would become desirable to detect empty
  6024.    loops and delete them, since this optimization could make empty loops.  */
  6025.  
  6026. static rtx
  6027. final_biv_value (bl, loop_end)
  6028.      struct iv_class *bl;
  6029.      rtx loop_end;
  6030. {
  6031.   /* wimpy, but guaranteed to work */
  6032.   return 0;
  6033. }
  6034.  
  6035. /* Return nonzero if the last use of reg REGNO
  6036.    is in an insn following INSN in the same basic block.  */
  6037.  
  6038. static int
  6039. last_use_this_basic_block (regno, insn)
  6040.      int regno;
  6041.      rtx insn;
  6042. {
  6043.   rtx n;
  6044.   for (n = insn;
  6045.        n && GET_CODE (n) != CODE_LABEL && GET_CODE (n) != JUMP_INSN;
  6046.        n = NEXT_INSN (n))
  6047.     {
  6048.       if (regno_last_uid[regno] == INSN_UID (n))
  6049.     return 1;
  6050.     }
  6051.   return 0;
  6052. }
  6053. #if defined( DSP96000 ) || defined( DSP56000 )
  6054. /* find the first mem expression encountered. */
  6055. static rtx
  6056. find_mem ( pattern )
  6057.     rtx pattern;
  6058. {
  6059.     if ( ! pattern )
  6060.     {
  6061.     return 0;
  6062.     }
  6063.     if ( MEM == GET_CODE ( pattern ))
  6064.     {
  6065.     return pattern;
  6066.     }
  6067.     {
  6068.     int i = GET_RTX_LENGTH ( GET_CODE ( pattern )) - 1;
  6069.     char* f = GET_RTX_FORMAT ( GET_CODE ( pattern ));
  6070.     rtx found;
  6071.     
  6072.     while ( i >= 0 )
  6073.     {
  6074.         if ( 'e' == f[i] &&
  6075.         ( found = find_mem ( XEXP ( pattern, i ))))
  6076.         {
  6077.         return found;
  6078.         }
  6079.         if ( 'E' == f[i] )
  6080.         {
  6081.         int j = XVECLEN ( pattern, i ) - 1;
  6082.  
  6083.         while ( j >= 0 )
  6084.         {
  6085.             if ( found = find_mem ( XVECEXP ( pattern, i, j )))
  6086.             {
  6087.             return found;
  6088.             }
  6089.             -- j;
  6090.         }
  6091.         }
  6092.         -- i;
  6093.     }
  6094.     }
  6095.     return 0;
  6096. }
  6097. /* find the label referenced by this conditional jump insn. if the jump
  6098.  * isn't conditional, return NULL.
  6099.  */
  6100. static rtx
  6101. get_bcond_label ( insn )
  6102.     rtx insn;
  6103. {
  6104.     rtx pat = PATTERN ( insn );
  6105.     
  6106.     if ( IF_THEN_ELSE != GET_CODE ( pat = SET_SRC ( pat )))
  6107.     {
  6108.     return NULL;
  6109.     }
  6110.     if ( LABEL_REF == GET_CODE ( XEXP ( pat, 1 )))
  6111.     {
  6112.     return XEXP ( XEXP ( pat, 1 ), 0 );
  6113.     }
  6114.     if ( LABEL_REF == GET_CODE ( XEXP ( pat, 2 )))
  6115.     {
  6116.     return XEXP ( XEXP ( pat, 2 ), 0 );
  6117.     }
  6118.     return NULL;
  6119. }
  6120.  
  6121. /* is expr a const expression ? */
  6122. static int
  6123. const_expr_p ( expr )
  6124.     rtx expr;
  6125. {
  6126.     switch ( GET_CODE ( expr ))
  6127.     {
  6128.     case CONST_INT:
  6129.     case CONST:
  6130.     case CONST_DOUBLE:
  6131.     case SYMBOL_REF:
  6132.     return 1;
  6133.     
  6134.     case PLUS:
  6135.     case MINUS:
  6136.     return ( const_expr_p ( XEXP ( expr, 0 )) &&
  6137.         const_expr_p ( XEXP ( expr, 1 )));
  6138.     
  6139.     default:
  6140.     return 0;
  6141.     }
  6142. }
  6143.  
  6144. /* try to find the "best" equivalent rtx for this rtx - we are trying to 
  6145.  * show that this rtx is actually loop invariant.
  6146.  */
  6147. static rtx 
  6148. find_best_equiv ( init, use_insn, stop_insn )
  6149.     rtx init, use_insn, stop_insn;
  6150. {
  6151.     /* use the limit technique to stop a feedback situation. */
  6152.     static int max_search_depth = 10;
  6153.     rtx tmp;
  6154.     
  6155.     /* a constant expression is the *best* loop invariant possible ! */
  6156.     if ( const_expr_p ( init ))
  6157.     {
  6158.     return init;
  6159.     }
  6160.     
  6161.     /* anything but a REG would be illegal here. */
  6162.     if ( REG != GET_CODE ( init ))
  6163.     {
  6164.     return NULL;
  6165.     }
  6166.     
  6167.     /* step from the use_insn up towards the stop_insn, looking for an insn
  6168.      * that sets init. 
  6169.      */
  6170.  
  6171.     tmp = use_insn;
  6172.     while ( tmp = PREV_INSN ( tmp ), 
  6173.        ( tmp != stop_insn ) && 
  6174.        ( CODE_LABEL != GET_CODE ( tmp )) &&
  6175.        ! (( INSN == GET_CODE ( tmp )) &&
  6176.           ( SET == GET_CODE ( PATTERN ( tmp ))) &&
  6177.           ( init == SET_DEST ( PATTERN ( tmp )))));
  6178.     
  6179.     /* do we have an acceptable SET ? */
  6180.     if (( INSN == GET_CODE ( tmp )) &&
  6181.     ( SET == GET_CODE ( PATTERN ( tmp ))) &&
  6182.     ( init == SET_DEST ( PATTERN ( tmp ))) &&
  6183.     ( max_search_depth ))
  6184.     {
  6185.     rtx src = SET_SRC ( PATTERN ( tmp ));
  6186.     while ( SUBREG == GET_CODE ( src ))
  6187.     {
  6188.         src = XEXP ( src, 0 );
  6189.     }
  6190.     
  6191.     -- max_search_depth;
  6192.     tmp = find_best_equiv ( src, use_insn, stop_insn );
  6193.     ++ max_search_depth;
  6194.     return tmp;
  6195.     }
  6196.  
  6197.     /* we have a register which is supposedly our loop invariant loop bound:
  6198.      * now we make sure that it is really invariant in the loop.
  6199.      */
  6200.  
  6201.     if ( reg_set_between_p ( init, stop_insn, use_insn ))
  6202.     {
  6203.     return NULL;
  6204.     }
  6205.     return init;
  6206. }
  6207. /* compute the loop count from the parameters given. if the computation will
  6208.  * take place at run time, we may need to check for <=0 iterations, and bypass
  6209.  * the loop. form: for ( i = a; i rel b; i += c ). return NULL if this loop
  6210.  * is un-do-able.
  6211.  */
  6212. static rtx
  6213. compute_loop_count ( start, search_bound, bypass, a, rel, b, c )
  6214.     rtx start, search_bound, bypass, a, rel, b, c;
  6215. {
  6216.     int tmp, signed_cmp = 0;
  6217.     unsigned int utmp;
  6218.     enum rtx_code code = GET_CODE ( rel );
  6219.     
  6220. #define CLEAN_TO_BITS_PER_UNIT( x )\
  6221.     ((((unsigned int)x)<<(HOST_BITS_PER_INT-BITS_PER_UNIT))>>\
  6222.      (HOST_BITS_PER_INT-BITS_PER_UNIT))
  6223.  
  6224.     /* if everything is a constant, we can figure out the loop count now. */
  6225.     if (( CONST_INT == GET_CODE ( a )) &&
  6226.     ( CONST_INT == GET_CODE ( b )) &&
  6227.     ( CONST_INT == GET_CODE ( c )))
  6228.     {
  6229.     int a_s, b_s, c_s;
  6230.     unsigned int a_u, b_u, c_u;
  6231.     
  6232.     switch ( code )
  6233.     {
  6234.     case GT:
  6235.         signed_cmp = 1;
  6236.         a_s = INTVAL ( b );
  6237.         b_s = INTVAL ( a ) - 1;
  6238.         c_s = - INTVAL ( c );
  6239.         break;
  6240.         
  6241.     case LT:
  6242.         signed_cmp = 1;
  6243.         a_s = INTVAL ( a );
  6244.         b_s = INTVAL ( b ) - 1;
  6245.         c_s = INTVAL ( c );
  6246.         break;
  6247.         
  6248.     case GTU:
  6249.         a_u = INTVAL ( b );
  6250.         b_u = INTVAL ( a ) - 1;
  6251.         c_u = - INTVAL ( c );
  6252.         break;
  6253.  
  6254.     case LTU:
  6255.         a_u = INTVAL ( a );
  6256.         b_u = INTVAL ( b ) - 1;
  6257.         c_u = INTVAL ( c );
  6258.         break;
  6259.         
  6260.     case GE:
  6261.         signed_cmp = 1;
  6262.         a_s = INTVAL ( b );
  6263.         b_s = INTVAL ( a );
  6264.         c_s = - INTVAL ( c );
  6265.         break;
  6266.     
  6267.     case LE:
  6268.         signed_cmp = 1;
  6269.         a_s = INTVAL ( a );
  6270.         b_s = INTVAL ( b );
  6271.         c_s = INTVAL ( c );
  6272.         break;
  6273.  
  6274.     case GEU:
  6275.         a_u = INTVAL ( b );
  6276.         b_u = INTVAL ( a );
  6277.         c_u = - INTVAL ( c );
  6278.         break;
  6279.  
  6280.     case LEU:
  6281.         a_u = INTVAL ( a );
  6282.         b_u = INTVAL ( b );
  6283.         c_u = INTVAL ( c );
  6284.         break;
  6285.         
  6286. #if defined( DSP56000 )
  6287.     case NEU:
  6288.         /* this is analogous to the NE case, but for unsigned values */
  6289. #endif
  6290.     case NE:
  6291.         /* this is a special case: we really have a > or < situation.
  6292.          * determine which, and set a_u, b_u, c_u accordingly. 
  6293.          */
  6294.         if ( 0 > INTVAL ( c ))
  6295.         {
  6296.         /* case GT or GTU */
  6297.         a_u = INTVAL ( b );
  6298.         b_u = INTVAL ( a ) - 1;
  6299.         c_u = - INTVAL ( c );
  6300.         }
  6301.         else if ( 0 < INTVAL ( c ))
  6302.         {
  6303.         /* case LT or LTU */
  6304.         a_u = INTVAL ( a );
  6305.         b_u = INTVAL ( b ) - 1;
  6306.         c_u = INTVAL ( c );
  6307.         }
  6308.         else
  6309.         {
  6310.         return NULL;
  6311.         }
  6312.         break;
  6313.         
  6314.     default:
  6315.         return NULL;
  6316.     }
  6317.     
  6318.     /* compute ceiling( ( b - a + 1 ) / c ) as the iteration count. if 
  6319.      * we count zero iterations, bail.
  6320.      */
  6321.     if ( signed_cmp )
  6322.     {
  6323.         tmp = CLEAN_TO_BITS_PER_UNIT ( 1 + b_s - a_s ) / c_s;
  6324.         tmp += ( CLEAN_TO_BITS_PER_UNIT ( c_s * tmp ) != 
  6325.              CLEAN_TO_BITS_PER_UNIT ( 1 + b_s - a_s )) ? 1 : 0;
  6326.  
  6327.         if ( 0 >= tmp )
  6328.         return NULL;
  6329.     }
  6330.     else
  6331.     {
  6332.         utmp = CLEAN_TO_BITS_PER_UNIT ( 1 + b_u - a_u ) / c_u;
  6333.         utmp += ( CLEAN_TO_BITS_PER_UNIT ( c_u * utmp ) !=
  6334.               CLEAN_TO_BITS_PER_UNIT ( 1 + b_u - a_u )) ? 1 : 0;
  6335.         
  6336.         if ( 0 == utmp )
  6337.         return NULL;
  6338.     }
  6339.     
  6340.     return gen_rtx ( CONST_INT, VOIDmode, 
  6341.             ( signed_cmp ) ? tmp : utmp );
  6342.     }
  6343.     /* if a or b is non-constant, we need to have a power of two const for c */
  6344.     /* for 1st release: only consider the case of +/- 1. */
  6345.     else if (( CONST_INT == GET_CODE ( c )) &&
  6346.          (((( 1 == INTVAL ( c ))/* ||
  6347.         (( 0 < INTVAL ( c )) && ( 0 == INTVAL ( c ) % 2 ))*/) &&
  6348.            (( LT == code ) || ( LTU == code ) ||
  6349.         ( LE == code ) || ( LEU == code ))) ||
  6350.           ((( -1 == INTVAL ( c ))/* ||
  6351.         (( 0 > INTVAL ( c )) && ( 0 == ( - INTVAL ( c )) % 2 ))*/) &&
  6352.            (( GT == code ) || ( GTU == code ) ||
  6353.         ( GE == code ) || ( GEU == code )))))
  6354.     {
  6355.     /* we can do do-loops for modes <= SImode in width. */
  6356.     if (( GET_MODE_SIZE ( SImode ) < GET_MODE_SIZE ( GET_MODE ( a ))) ||
  6357.         ( GET_MODE_SIZE ( SImode ) < GET_MODE_SIZE ( GET_MODE ( b ))))
  6358.     {
  6359.         return 0;
  6360.     }
  6361.     
  6362.     /* force both operands into registers for the loop count computation */
  6363.     if ( REG != GET_CODE ( a ))
  6364.     {
  6365.         rtx tmp = gen_reg_rtx (( VOIDmode == GET_MODE ( a )) ?
  6366.                    (( VOIDmode == GET_MODE ( b )) ? SImode :
  6367.                     b->mode ) : a->mode );
  6368.         
  6369.         emit_insn_before ( gen_rtx ( SET, VOIDmode, tmp, a ), start );
  6370.         a = tmp;
  6371.     }
  6372.  
  6373.     if ( REG != GET_CODE ( b ))
  6374.     {
  6375.         rtx tmp = gen_reg_rtx (( VOIDmode == GET_MODE ( b )) ?
  6376.                    a->mode : b->mode );
  6377.         
  6378.         emit_insn_before ( gen_rtx ( SET, VOIDmode, tmp, b ), start );
  6379.         b = tmp;
  6380.     }
  6381.     
  6382.     /* generate loop count computation and verification code. */
  6383.     if ( 1 == INTVAL ( c ))
  6384.     { 
  6385.         rtx ret_tmp = gen_reg_rtx ( SImode );
  6386.         rtx cond = gen_rtx ( flip_cond_code ( code ), VOIDmode, cc0_rtx,
  6387.                 const0_rtx );
  6388.         rtx target = gen_rtx ( LABEL_REF, Pmode, bypass );
  6389.         rtx const1_reg;
  6390.         
  6391.         if ( ! pre_existing_test_p ( start, search_bound, a, b, 
  6392.                     GET_CODE ( cond ), target, pc_rtx ))
  6393.         {
  6394.         emit_insn_before ( gen_rtx ( SET, VOIDmode, cc0_rtx, 
  6395.                         gen_rtx ( COMPARE, VOIDmode, 
  6396.                              a, b )), start );
  6397.         
  6398.         emit_insn_before ( gen_rtx ( SET, VOIDmode, pc_rtx,
  6399.                         gen_rtx ( IF_THEN_ELSE,
  6400.                              VOIDmode, cond, target,
  6401.                              pc_rtx )), start );
  6402.         }
  6403.  
  6404.  
  6405.         switch ( code )
  6406.         {
  6407.         case LT:
  6408.         case LTU:
  6409.         emit_insn_before ( gen_rtx ( SET, VOIDmode, ret_tmp,
  6410.                         gen_rtx ( MINUS, b->mode, b, a )),
  6411.                   start );
  6412.         return ret_tmp;
  6413.         break;
  6414.  
  6415.         case LE:
  6416.         case LEU:
  6417.         emit_insn_before ( gen_rtx ( SET, VOIDmode, ret_tmp,
  6418.                         gen_rtx ( MINUS, b->mode, b, a )),
  6419.                   start );
  6420.         
  6421.         const1_reg = gen_reg_rtx ( SImode );
  6422.         
  6423.         emit_insn_before ( gen_rtx ( SET, VOIDmode, const1_reg,
  6424.                         const1_rtx ), start );
  6425.         
  6426.         emit_insn_before ( gen_rtx ( SET, VOIDmode, ret_tmp,
  6427.                         gen_rtx ( PLUS, SImode, ret_tmp,
  6428.                              const1_reg )),
  6429.                   start );
  6430.         
  6431.         return ret_tmp;
  6432.         break;
  6433.         
  6434.         case GT:
  6435.         case GTU:
  6436.         emit_insn_before ( gen_rtx ( SET, VOIDmode, ret_tmp,
  6437.                         gen_rtx ( MINUS, b->mode, a, b )),
  6438.                   start );
  6439.         return ret_tmp;
  6440.         break;
  6441.         
  6442.         case GE:
  6443.         case GEU:
  6444.         emit_insn_before ( gen_rtx ( SET, VOIDmode, ret_tmp,
  6445.                         gen_rtx ( MINUS, b->mode, a, b )),
  6446.                   start );
  6447.         
  6448.         const1_reg = gen_reg_rtx ( SImode );
  6449.         
  6450.         emit_insn_before ( gen_rtx ( SET, VOIDmode, const1_reg,
  6451.                         const1_rtx ), start );
  6452.         
  6453.         emit_insn_before ( gen_rtx ( SET, VOIDmode, ret_tmp,
  6454.                         gen_rtx ( PLUS, SImode, ret_tmp,
  6455.                              const1_reg )),
  6456.                   start );
  6457.         
  6458.         return ret_tmp;
  6459.         break;
  6460.         }
  6461.     }
  6462.     return NULL;
  6463.     }
  6464.     /* we can't (realistically) do this loop. */
  6465.     return NULL;
  6466. }
  6467.  
  6468. /* we want to be able to trace back through dsts to tell if the reg was really
  6469.  * ever used in other than an increment situation. we punt on feedback 
  6470.  * situations where an inc or self-mod might involve multiple regs. we go ahead
  6471.  * with this simple recursive code and punt if we go > 10 searches deep. 
  6472.  */
  6473. static int
  6474. reg_really_used_between_p ( reg, from_insn, to_insn )
  6475.     rtx reg, from_insn, to_insn;
  6476. {
  6477.     static int max_search_depth = 10;
  6478.     rtx insn;
  6479.     RTX_CODE code;
  6480.     
  6481.     for ( insn = NEXT_INSN ( from_insn );
  6482.      insn != to_insn; insn = NEXT_INSN ( insn ))
  6483.     {
  6484.     if (((code = GET_CODE (insn)) == INSN
  6485.          || code == JUMP_INSN || code == CALL_INSN)
  6486.         && reg_mentioned_p (reg, PATTERN (insn)))
  6487.     {
  6488.         if (( INSN == code ) &&
  6489.         ( SET == GET_CODE ( PATTERN ( insn ))) &&
  6490.         ( REG == GET_CODE ( SET_DEST ( PATTERN ( insn )))))
  6491.         {
  6492.         if (( reg != SET_DEST ( PATTERN ( insn ))) &&
  6493.             ( max_search_depth ))
  6494.         {
  6495.             -- max_search_depth;
  6496.             
  6497.             if ( reg_really_used_between_p ( SET_DEST ( PATTERN ( insn )),
  6498.                             from_insn, to_insn ))
  6499.             {
  6500.             ++ max_search_depth;
  6501.             return 1;
  6502.             }
  6503.             ++ max_search_depth;
  6504.         }
  6505.         }
  6506.         else
  6507.         {
  6508.         return 1;
  6509.         }
  6510.     }
  6511.     }
  6512.     return 0;
  6513. }
  6514. static int
  6515. biv_qualified_p ( biv, label, branch )
  6516.     rtx biv, label, branch;
  6517. {
  6518.     /* if we have multiple sets of this register, the GNU biv info is
  6519.      * essentially unreliable. we don't yet have any dataflow info so ...
  6520.      */
  6521.     if ( 1 < n_times_set[ REGNO ( biv ) ] )
  6522.     {
  6523.     return 0;
  6524.     }
  6525.  
  6526.     {
  6527.     rtx peek = NEXT_INSN ( label );
  6528.     rtx goal = class_struct[ REGNO ( biv ) ]->biv->insn;
  6529.     
  6530.     /* scan from the loop continuation label downward to see if 
  6531.      * we can find the insn which sets the biv. if we encounter a
  6532.      * label or a jump abandon the search and search upward from
  6533.      * the back-branch insn. if we still can't find the set, then
  6534.      * we really can't be sure that the biv will be altered on each 
  6535.      * iteration. again, it would have been nice to have dataflow 
  6536.      * info here ...
  6537.      */
  6538.     while (( CODE_LABEL != GET_CODE ( peek )) &&
  6539.            ( JUMP_INSN != GET_CODE ( peek )))
  6540.     {
  6541.         if ( peek == goal )
  6542.         {
  6543.         return 1;
  6544.         }
  6545.         peek = NEXT_INSN ( peek );
  6546.     }
  6547.     
  6548.     peek = PREV_INSN ( branch );
  6549.     while (( CODE_LABEL != GET_CODE ( peek )) &&
  6550.            ( JUMP_INSN != GET_CODE ( peek )))
  6551.     {
  6552.         if ( peek == goal )
  6553.         {
  6554.         return 1;
  6555.         }
  6556.         peek = PREV_INSN ( peek );
  6557.     }
  6558.     }
  6559.     return 0;
  6560. }
  6561.  
  6562. static int
  6563. no_jumps_out_of_loop_p ( start, end )
  6564.     rtx start, end;
  6565. {
  6566.     int do_depth = 1;
  6567.     
  6568.     rtx step = start;
  6569.     int label_max = 50, label_high_water = 0;
  6570.     int jump_max = 50, jump_high_water = 0;
  6571.     rtx jump[ 50 ], label[ 50 ];
  6572.     int index;
  6573.  
  6574.     for ( ; step != end; step = NEXT_INSN ( step ))
  6575.     {
  6576.     if ( ! step )
  6577.     {
  6578.         return 0;
  6579.     }
  6580.  
  6581.     if ( insn_is_do_p ( step ))
  6582.     {
  6583.         if (( ++ do_depth ) > MAX_DO_LOOP_NESTING )
  6584.         {
  6585.         return 0;
  6586.         }
  6587.         continue;
  6588.     }
  6589.     
  6590.     if ( insn_is_od_p ( step ))
  6591.     {
  6592.         -- do_depth;
  6593.         
  6594.         continue;
  6595.     }
  6596.     
  6597.     if ( CALL_INSN == GET_CODE ( step ))
  6598.     {
  6599.         return 0;
  6600.     }
  6601.     
  6602.     if ( JUMP_INSN == GET_CODE ( step ))
  6603.     {
  6604.         rtx label_referenced;
  6605.         
  6606.         if ( ! ( label_referenced = get_bcond_label ( step )))
  6607.         {
  6608.         if ( PARALLEL != GET_CODE ( PATTERN ( step )))
  6609.         {
  6610.             if (( SET != GET_CODE ( PATTERN ( step ))) ||
  6611.             ( LABEL_REF != 
  6612.              GET_CODE ( SET_SRC ( PATTERN ( step )))))
  6613.             {
  6614.             return 0;
  6615.             }
  6616.             label_referenced = XEXP ( SET_SRC ( PATTERN ( step )),
  6617.                          0 );
  6618.         }
  6619.         else
  6620.         {
  6621.             continue;
  6622.         }
  6623.         }
  6624.                        
  6625.         for ( index = 0; index < label_high_water; ++ index )
  6626.         {
  6627.         if ( label[ index ] == label_referenced )
  6628.         {
  6629.             label_referenced = NULL;
  6630.             break;
  6631.         }
  6632.         }
  6633.         if ( label_referenced )
  6634.         {
  6635.         for ( index = 0; index < jump_high_water; ++ index )
  6636.         {
  6637.             if ( ! jump[ index ] )
  6638.             {
  6639.             jump[ index ] = label_referenced;
  6640.             break;
  6641.             }
  6642.         }
  6643.         if ( index == jump_high_water )
  6644.         {
  6645.             if ( jump_high_water == jump_max )
  6646.             {
  6647.             return 0;
  6648.             }
  6649.             jump[ jump_high_water ++ ] = label_referenced;
  6650.         }
  6651.         }
  6652.     }
  6653.     else if ( CODE_LABEL == GET_CODE ( step ))
  6654.     {
  6655.         for ( index = 0; index < jump_high_water; ++ index )
  6656.         {
  6657.         if ( jump[ index ] == step )
  6658.         {
  6659.             jump[ index ] = NULL;
  6660.         }
  6661.         }
  6662.         if ( label_max == label_high_water )
  6663.         {
  6664.         return 0;
  6665.         }
  6666.         label[ label_high_water ++ ] = step;
  6667.     }
  6668.     }
  6669.     for ( index = 0; index < jump_high_water; ++ index )
  6670.     {
  6671.     if ( jump[ index ] )
  6672.     {
  6673.         return 0;
  6674.     }
  6675.     }
  6676.     return 1;
  6677. }
  6678.  
  6679. static int
  6680. insn_is_do_p ( insn )
  6681.     rtx insn;
  6682. {
  6683.     if (( JUMP_INSN == GET_CODE ( insn )) &&
  6684.     ( PARALLEL == GET_CODE ( PATTERN ( insn ))) &&
  6685.     ( 3 == XVECLEN ( PATTERN ( insn ), 0 )))
  6686.     {
  6687.     return 1;
  6688.     }
  6689.     return 0;
  6690. }
  6691.  
  6692. static int
  6693. insn_is_od_p ( insn )
  6694.     rtx insn;
  6695. {
  6696.     if (( JUMP_INSN == GET_CODE ( insn )) &&
  6697.     ( PARALLEL == GET_CODE ( PATTERN ( insn ))) &&
  6698.     ( 2 == XVECLEN ( PATTERN ( insn ), 0 )))
  6699.     {
  6700.     return 1;
  6701.     }
  6702.     return 0;
  6703. }
  6704.  
  6705. static int
  6706. rtx_label_equiv_p ( lab1, lab2 )
  6707.     rtx lab1, lab2;
  6708. {
  6709.     if ( rtx_equal_p ( lab1, lab2 ))
  6710.     {
  6711.     return 1;
  6712.     }
  6713.     
  6714.     if (( LABEL_REF == GET_CODE ( lab1 )) &&
  6715.     ( LABEL_REF == GET_CODE ( lab2 )))
  6716.     {
  6717.     rtx ref_insn = XEXP ( lab1, 0 );
  6718.     rtx walker = XEXP ( lab2, 0 );
  6719.     
  6720.     do 
  6721.     {
  6722.         walker = PREV_INSN ( walker );
  6723.         
  6724.         if ( walker == ref_insn )
  6725.         {
  6726.         return 1;
  6727.         }
  6728.     }
  6729.     while (( NULL != walker ) &&
  6730.            (( NOTE == GET_CODE ( walker )) ||
  6731.         ( CODE_LABEL == GET_CODE ( walker )) ||
  6732.         (( INSN == GET_CODE ( walker )) &&
  6733.          ( const0_rtx == PATTERN ( walker )))));
  6734.     
  6735.     walker = XEXP ( lab2, 0 );
  6736.     
  6737.     do 
  6738.     {
  6739.         walker = NEXT_INSN ( walker );
  6740.         
  6741.         if ( walker == ref_insn )
  6742.         {
  6743.         return 1;
  6744.         }
  6745.     }
  6746.     while (( NULL != walker ) &&
  6747.            (( NOTE == GET_CODE ( walker )) ||
  6748.         ( CODE_LABEL == GET_CODE ( walker )) ||
  6749.         (( INSN == GET_CODE ( walker )) &&
  6750.          ( const0_rtx == PATTERN ( walker )))));
  6751.     }
  6752.     return 0;
  6753. }
  6754.  
  6755. static int
  6756. pre_existing_test_p ( base_insn, search_bound, 
  6757.              cmp_a, cmp_b, cond_code, target, drop )
  6758.     rtx base_insn, search_bound, cmp_a, cmp_b, target, drop;
  6759.     enum rtx_code cond_code;
  6760. {
  6761.     /* look backwards up the basic block, checking for mods to cmp_a or
  6762.        cmp_b, and or CALL_INSNs */
  6763.  
  6764.     rtx insn = PREV_INSN ( base_insn );
  6765.     
  6766.     if ((( REG != GET_CODE ( cmp_a )) && ( ! CONSTANT_P ( cmp_a ))) ||
  6767.     (( REG != GET_CODE ( cmp_b )) && ( ! CONSTANT_P ( cmp_b ))))
  6768.     {
  6769.     return 0;
  6770.     }
  6771.     
  6772.     while (( NULL != insn ) && ( JUMP_INSN != GET_CODE ( insn )))
  6773.     {
  6774.     if ( reg_set_p ( cmp_a, insn ) || reg_set_p ( cmp_b, insn ) ||
  6775.         ( CALL_INSN == GET_CODE ( insn )))
  6776.     {
  6777.         return 0;
  6778.     }
  6779.     insn = PREV_INSN ( insn );
  6780.     }
  6781.     
  6782.     if ( NULL == insn )
  6783.     {
  6784.     return 0;
  6785.     }
  6786.     
  6787.     /* check to see that the jmp insn is compatable */
  6788.  
  6789.     {
  6790.     rtx body = PATTERN ( insn );
  6791.     
  6792.     if (( SET != GET_CODE ( body )) || ( pc_rtx != SET_DEST ( body )))
  6793.     {
  6794.         return 0;
  6795.     }
  6796.     
  6797.     body = SET_SRC ( body );
  6798.     
  6799.     if (( IF_THEN_ELSE != GET_CODE ( body )) ||
  6800.         ((( ! rtx_equal_p ( XEXP ( body, 0 ), 
  6801.                    gen_rtx ( cond_code, VOIDmode,
  6802.                     cc0_rtx, const0_rtx ))) ||
  6803.           ( ! rtx_label_equiv_p ( XEXP ( body, 1 ), target )) ||
  6804.           ( ! rtx_label_equiv_p ( XEXP ( body, 2 ), drop ))) &&
  6805.          (( ! rtx_equal_p ( XEXP ( body, 0 ), 
  6806.                    gen_rtx ( flip_cond_code ( cond_code ), 
  6807.                     VOIDmode, cc0_rtx, const0_rtx ))) ||
  6808.           ( ! rtx_label_equiv_p ( XEXP ( body, 1 ), drop )) ||
  6809.           ( ! rtx_label_equiv_p ( XEXP ( body, 2 ), target )))))
  6810.     {
  6811.         return 0;
  6812.     }
  6813.     
  6814.     /* the jmp checked out, move on to the cmp */
  6815.     
  6816.     do
  6817.     {
  6818.         insn = PREV_INSN ( insn );
  6819.     }
  6820.     while (( NULL != insn ) && ( NOTE == GET_CODE ( insn )));
  6821.     
  6822.     if (( NULL == insn ) || ( INSN != GET_CODE ( insn )))
  6823.     {
  6824.         return 0;
  6825.     }
  6826.     
  6827.     body = PATTERN ( insn );
  6828.     
  6829.     if (( SET != GET_CODE ( body )) ||
  6830.         ( cc0_rtx != SET_DEST ( body )) ||
  6831.         ( COMPARE != GET_CODE ( SET_SRC ( body ))))
  6832.     {
  6833.         return 0;
  6834.     }
  6835.     
  6836.     { 
  6837.         rtx best_val1 = find_best_equiv ( XEXP ( SET_SRC ( body ), 0 ),
  6838.                          base_insn, search_bound );
  6839.  
  6840.         rtx best_val2 = find_best_equiv ( XEXP ( SET_SRC ( body ), 1 ),
  6841.                          base_insn, search_bound );
  6842.         
  6843.         rtx best_cmp_a = find_best_equiv ( cmp_a, 
  6844.                           base_insn, search_bound );
  6845.  
  6846.         rtx best_cmp_b = find_best_equiv ( cmp_b,
  6847.                           base_insn, search_bound );
  6848.  
  6849.         best_val1 = ( best_val1 ) ? 
  6850.         best_val1 : XEXP ( SET_SRC ( body ), 0 );
  6851.  
  6852.         best_val2 = ( best_val2 ) ? 
  6853.         best_val2 : XEXP ( SET_SRC ( body ), 1 );
  6854.         
  6855.         best_cmp_a = ( best_cmp_a ) ? best_cmp_a : cmp_a;
  6856.         
  6857.         best_cmp_b = ( best_cmp_b ) ? best_cmp_b : cmp_b;
  6858.         
  6859.         if (( ! rtx_equal_p ( best_cmp_a, best_val1 )) ||
  6860.         ( ! rtx_equal_p ( best_cmp_b, best_val2 )))
  6861.         {
  6862.         return 0;
  6863.         }
  6864.     }
  6865.     }
  6866.     return 1;
  6867. }
  6868.  
  6869. static enum rtx_code
  6870. flip_cond_code ( orig_code )
  6871.     enum rtx_code orig_code;
  6872. {
  6873.     switch ( orig_code )
  6874.     {
  6875.     case NE:
  6876.     return EQ;
  6877.     case EQ:
  6878.     return NE;
  6879.     case GE:
  6880.     return LT;
  6881.     case GT:
  6882.     return LE;
  6883.     case LE:
  6884.     return GT;
  6885.     case LT:
  6886.     return GE;
  6887. #if defined( DSP56000 )
  6888.     case NEU:
  6889.     return EQU;
  6890.     case EQU:
  6891.     return NEU;
  6892. #endif
  6893.     case GEU:
  6894.     return LTU;
  6895.     case GTU:
  6896.     return LEU;
  6897.     case LEU:
  6898.     return GTU;
  6899.     case LTU:
  6900.     return GEU;
  6901.     
  6902.     default:
  6903.     return UNKNOWN;
  6904.     }
  6905. }
  6906. #endif
  6907.  
  6908.  
  6909.